c++11 using std::fill to fill a 2D dynamically allocated array

Pointer arithmetic requires that a pointer be incremented only to the extent that the result still points at the same array (or one past the end).

You allocate each row as a separate array in your for loop:

for(int i = 0 ; i < col ; i++) data[i] = new double[col]; // this creates a distinct array for each row 

Since each row array you allocate is col elements, the maximum value that can legally be added to &(data[0][0]) is col. But in each of your examples of std::fill usage you add more to the pointer than you are allowed.

Given the way you are allocating the array, there's no way for you to pass raw pointers to a single call to std::fill in order to initialize the entire 2D array. Either you must use more than one call to std::fill (which defeats the purpose of using std::fill), or you must create an Iterator type that knows how to deal with the separate allocation of each row, or you must change the way you allocate the array.

I would recommend allocating the whole array at once as a single dimensional array and then writing some additional code to make it work like a two dimensional array. This has a number of benefits:

• The standard library contains a convenient way of dynamically allocating a single dimensional arrays: std::vector
• Using std::vector means you no longer need to use naked new and delete, which fixes the exception safety problem your code has.
• A single allocation generally has better performance characteristics than many allocations (Of course, there are cases where separate allocations are better).

Here's a simple wrapper class to make a 1D array look like a 2D array:

class Matrix { std::vector<double> data; int cols; public: Matrix(int row, int col) : data(row * col) , cols(col) {} auto begin() { return data.begin(); } auto end() { return data.end(); } struct index_type { int row; int col; }; double &operator[](index_type i) { return data[i.row * cols + i.col]; } int row_count() const { return data.size()/cols; } int column_count() const { return cols; } }; 

Using this you can rewrite your code:

#include "Matrix.h" #include <iostream> #include <algorithm> using std::cout ; using std::endl ; using std::fill ; int main() { Matrix data(10, 10); fill(data.begin(), data.end(), 1.0); for(int i = 0 ; i < data.row_count() ; i++) { for(int j = 0 ; j < data.column_count() ; j++) cout << data[{i, j}] << " " ; cout << endl ; } } 

Does std::fill give any extra benefit over two nested loops?

Using loops is less readable because loops could do lots of other things, and you have to spend more time figuring out what any particular loop is doing. For this reason one should always prefer using STL algorithms over manual loops, all else being equal.

// fill(&(data[0][0]), // &(data[0][0]) + (row * col * sizeof(double)), 1); // approach 1 

Pointer arithmetic automatically considers the size of the array elements. You don't need sizeof(double). Multiplying by sizeof(double) here is the same as multiplying by sizeof(double) inside []. You wouldn't do: data[i * sizeof(double)], so don't do data + (i * sizeof(double)).

Your example code uses &(data[0][0]). Think about if this the same or different from data[0]. Consider both the type and the value of the expressions.

I agree with the above comments. You have allocated 10 separate arrays so you can't initialize these with a single std::fill call. Moreover, when you perform arithmetic operations on pointer of non-void types, a compiler automatically multiply your results by sizeof of a given type. However, when you use functions like memset or memcpy, you actually have to multiply number of elements by sizeof of a given types and pass it to one of these functions. It's because these function operate on bytes and they accept pointers of void type. Therefore it is impossible for compiler to take care of adjusting of sizes, because the void type has no specified size.