// Created by Robin Rademaker // edited by AZTECCO for Robin Rademaker // Rademaker Robin - Array practice in C++ Part 2 - 15/O3/2019 // [4] Multi-dimensional array with diagonal sum // Check part 1 before this. #include #include // for manipulating output // get used to avoid 'using namespace std;' /* premise: If you already know these topics then this takes you few minutes. If a topic is new feel free to ask The C++ way to deal with data is using STL features (std::vector std::array map and so on ). But here we just focus on plain array. -better readable code => function(or class) outside the main. ! ! ! Problem: how to pass an array as argument? (the function cannot guess the array size automatically) We have to give the size in some way. for fixed sizes known at compile time: 1 - with templates and reference: template < std::size_t X , std::size_t Y > myFunc( T(&array)[X][Y]){...cout< 2 is C style 1 - 3 is C++ style */ template void diagonalsSumOfSquareArray( const int( &arr )[ sideLength ][ sideLength ] ){ int diagonalSumFromTopRight = 0; int diagonalSumFromTopLeft = 0; // always choose for self-descriptive // code instead of comments for ( std::size_t i = 0 ; i < sideLength ; ++i ){ // indentation by 1 bcz from a phone diagonalSumFromTopLeft += arr[ i ][ i ]; diagonalSumFromTopRight += arr[ i ][ sideLength - i - 1 ]; } std::cout<< "diagonalSumFromTopLeft : " << diagonalSumFromTopLeft << std::endl << "diagonalSumFromTopRight : " << diagonalSumFromTopRight << std::endl; }// explained below // # # # the signature: # # # /* void ..... output 2 values( 2 diagonals sum ) we will print the result directly from our function. If we wish to return 2 values: std::pairs , pass a 3rd and 4th pointer as argument, design a type.. */ /* ...( const int(&arr)[sideLength][sideLength] ) reference to const -will not modify the input -clear and readable intent. Why? because our function is intended to output a value from an input and not modify some data. */ /* template - size_t is specific type for sizes (unsigned and integer) - template can automatically get the sizes from a reference. And we can use sideLength inside the func. but we have 2 sides! using only one ensures the array is quadratic if you pass a rectangular array the functio will fail using only one template let the compiler warn you against rectangular topic : templates => really hard even for the compiler lol -better to skip -this is a very used formula however */ /* the size_t parameter could be omitted ( input = 3x3 fixed dimension ) May be good consider a more generic approach hence a variable size but always quadratic 3x3 2x2 5x5 ... */ /* parameters names (debatable) P_arr / or pData pArr for pointers R_arr for references? no.. just arr I like to show the type in a prefix* and separate with _ the name but it's a matter of choice. (* similar to UnrealEngine4 conventions) Althoug indicate a pointer is not used, a simple name like arr or data is enough. In this case is controversial because we should be using a container and the problem would not arise. * Rule : if you find hard to name properly a var,type,func or method there's something wrong in your design. */ // # # # the body. # # # /* 2 options 1- Humans think of 2d array as a surface. 2- machine sees only memory locations as ascending indexes. So we can : 1- use 2d array [x][y] 2- or normal array [x*y] * I personally prefer the 2nd but here we focus on 2d arrays so we use the 1st like you did * * * 2nd case iteration: for(i=0;i avoid it! If you need a variable just make it // here we use two templates because // this func just prints a 2d array of // any shape template void printArr( int(&arr)[R][C] ){ std::cout << "\n\n[4] Multi-dimensional array with diagonal sum\n\n"; for( std::size_t i = 0 ; i < R ; ++i ){ std::cout << "Row " << i + 1 << ": "; for( std::size_t j = 0 ; j < C ; ++j ){ std::cout.fill(' '); // i prefer a space std::cout << std::setw(2) << arr[i][j] << " "; } std::cout<< std::endl ; } } int main(){ // when accessing global data indicate it // using scope resolution :: printArr( ::sample_01 ); diagonalsSumOfSquareArray( ::sample_01 ); printArr( ::sample_02 ); diagonalsSumOfSquareArray( ::sample_02 ); // note how the main program is clear and // tidy // it's easy to see what happens return 0; }