C++ multi-dimensional array initialization

in C++ I want to initialize a double matrix (2-dimensional double array) like I would normally do without pointers like so:

    double data[4][4] = {
    1,0,0,0,
    0,1,0,0,
    0,0,1,0,
    0,0,0,1
};

However, since I want to return and pass it to functions, I need it as a double** pointer. So, basically I need to ini开发者_运维技巧tialize data in a nice way (as above), but then afterwards I need to save the pointer to the 2D-array without losing the data when the function exits.

Any help on this? :-)

Unless you are particular about pointers, I would prefer a reference here

void init( double (&r)[4][4]){
    // do assignment
    r[0][0] = 1;
}

int main(){
    double data[4][4] = {
        1,0,0,0,
        0,1,0,0,
        0,0,1,0,
        0,0,0,1
    };

    init(data);
}

By the way, if you pass it to a function in this manner, you would be "assigning" rather than "initializing".

Are all your matrices 4x4? Then I would simply define a class with a double[4][4] member and pass objects of that class around:

class Matrix
{
    double m[4][4];
    // ...
};

void function(const Matrix& matrix)
{
    // ...
}

If you need matrices of various dimensions, but they are known at compile time, use a template:

template <size_t n>
class Matrix
{
    double m[n][n];
    // ...
};

template <size_t n>
void function(const Matrix<n,n>& matrix)
{
    // ...
}

This saves you from dealing with array-to-pointer decay and makes the code more readable IMHO.

First, declaration of the double dimensional array is not correct. It needs to be done as follows:

double data[4][4] = {  
        {1.0,0,0,0},  
        {0,1,0,0},  
        {0,0,1,0},  
        {0,0,0,1}  
    };

Second, for passing it in a function you can do it like

show(data);

In the function declaration, you need to give the argument as an array with giving all dimensions except the first. So the declaration would look like:

void show(double arr[][4])
{
   ...
   ...
}

This passes the array as a reference wihout you needing to use a pointer.

Hope this helped.

double (*)[4] is very different from double **

Just sketch the layout of your doubles in the memory for both and you should understand why you can't use them interchangeably.

Initialize temporary variable in this way and then copy it to the dynamically allocated memory.

How about this (with pointers, and does what you asked for)

#include <iostream>

using namespace std;

int refer(double (*a)[4])
{
   cout<<"First value is "<<(*a)[0];
   (*a)[0] = 37;
   cout<<"changed value is "<<(*a)[0];
}

int main()
{
   double data[4][4] = {
    1.0,0,0,
    0,1,0,0,
    0,0,1,0,
    0,0,0,1
   };
   refer(data);
   return 0;
}

late to the party, but.... c++ is meant to work with c++ stl. (At least according to Bjarne Stroustrup if you're using raw pointers in c++ then you're doing something wrong.)

#include <array> // on top
// ..    

std::array<std::array<int, 4>, 4> data {{
    {1,0,0,0},
    {0,1,0,0},
    {0,0,1,0},
    {0,0,0,1}
}};

// access it normally 

data[1][2] = 123;
std::cout << data[0][0]; // prints 1. (#include <iostream>)

// You can return std::array from a function as a normal return value, don't worry it is not going to be reallocated, or missing.

std::array<std::array<int, 4>, 4> give_me_data() {
  std::array<std::array<int, 4>, 4> data {{
    {1,0,0,0},
    {0,1,0,0},
    {0,0,1,0},
    {0,0,0,1}
  }};
  return data;
}

(works with Mac's XCode, also gcc supports it https://stackoverflow.com/a/12616826/1031191)

What's the benetif? It works nicely with std algorithms, knows its size, same performance, etc. ref: std::array vs array performance