Dynamic memory allocation has undesired output

Question

So I started learning C++ last week and naturally, I want to become familiar with the whole pointer and object-oriented business and so on and so forth.

To do that, I'm writing a very simple program for some basic matrix calculations:

# include <iostream>
using std::cout;
using std::cin;

class Matrix {
        int columns; // x
        int rows; // y
        double* matrix;
    public:
        Matrix (int*);
        void printMatrix();
        void free() {
            delete[] matrix;
            return;
            };
};

Matrix::Matrix(int* dim){
    rows = *dim;
    columns = *(dim + 1);
    matrix = new double [columns*rows];
}

void Matrix::printMatrix(){ 
    int i, j;
    for(i = 0; i < columns; i++){
        for(j=0; j < rows; j++){
            cout << matrix[columns*i + j] << " ";
        }
        cout << "\n";
    }
    return;         
}


int* getMatrix ();

int main () {
    Matrix matrix (getMatrix());
    matrix.printMatrix();
    matrix.free();
    return 0;
}

int* getMatrix (){
    int* dim = new int [2];
    cout << "(m x n)-Matrix, m? ";
    cin >> dim[0];
    cout << "n? ";
    cin >> dim[1];
    return dim;
}

The problem (as I see it) occurs when I choose a (4,2) matrix. As I understand from various tutorials,

matrix = new double [columns*rows];

should allocate this much memory: columns*rows times sizeof(double). Also, every 'cell' should be initialized with a 0.

But, choosing a (4,2) matrix, I get the following output, of the function printMatrix():

0 0 
0 0 
0 6.6727e-319 
0 0

Why is the (3,2) entry not initialized with 0?

Thanks!

@Lightness Races in Orbit The accepted answer exactly answers this question. — Mark B, Jun 16 '14 at 17:18
@MarkB: Hmm okay. That doesn't make the questions the same (at all), but I'll leave it as is. — Lightness Races in Orbit, Jun 16 '14 at 17:19
@joBe: Once you get it working time to bring for a code review. http://codereview.stackexchange.com/ — Martin York, Jun 16 '14 at 23:23

Lightness Races in Orbit · Answer 1 · 2014-06-16T18:27:41.163

Also, every 'cell' should be initialized with a 0.

Nope. The language does not do that for you, when you write new double[N].

Why is the (3,2) entry not initialized with 0?

It will if, you write new double[N]() instead!

[C++11: 5.3.4/15]: A new-expression that creates an object of type T initializes that object as follows:

If the new-initializer is omitted, the object is default-initialized (8.5); if no initialization is performed, the object has indeterminate value.

Otherwise, the new-initializer is interpreted according to the initialization rules of 8.5 for direct-initialization.

Granted, this is slightly ambiguous in that it would seem to be talking about the non-array versions of new, but in fact it means both; T is double[4].

In fact, we can see that the same section of wording talks about "object" in both the array and non-array cases, setting the perfect precedent:

[C++11: 5.3.4/1]: [..] If the entity is a non-array object, the new-expression returns a pointer to the object created. If it is an array, the new-expression returns a pointer to the initial element of the array.

Now, it's essentially impossible to prove this rule, because you can strike unlucky and get all-zeroes even when those values are in fact indeterminate, but the following code entirely unconvincingly makes a good start:

#include <iostream>
#include <vector>

int main() {
    const std::size_t n = 4;

    {
        std::vector<double> hack;
        hack.push_back(5);
        hack.push_back(6);
        hack.push_back(7);
        hack.push_back(8);
        hack.push_back(9);
        hack.push_back(10);
        hack.push_back(11);
        hack.push_back(12);
    }

    double* a = new double [n];
    double* b = new double [n]();

    for (std::size_t i = 0; i < n; i++)
        std::cout << a[i] << '/' << b[i] << ' ';
    std::cout << '\n';

    delete[] a;
    delete[] b;
}

I managed to get 0/0 6/0 7/0 8/0 from it, thanks to some heap hackery, but it's still only just pure chance and doesn't really demonstrate anything (live demo).

Unfortunately, new double[4](316) isn't valid (providing a value inside the () is explicitly banned for arrays during direct-initialization, per [C++11: 8.5/16] ) so we can't suggest that new double[4](0) would be reliable and use the example with 316 to convince you of it.

I just tried it, but I still don't get 0. I only changed this line `matrix = new double [columns*rows]();`, and I still get __6.6727e-319__ as the (3,2) entry. — Jo Mo, Jun 16 '14 at 17:26
@JoBe: I've added a reference. Are you sure you recompiled your code? — Lightness Races in Orbit, Jun 16 '14 at 18:17

score 2 · Answer 2 · answered Jun 16 '14 at 17:18

2

Only static variables are initialized to 0 in C++.
Auto and dynamic variables should be initialized by you.

answered Jun 16 '14 at 17:18

cppcoder

22,227
6
56
81

Ok, but how come that it seems to always be zero with __this case__ being an exception? – Jo Mo Jun 16 '14 at 17:21
1

It is just by chance. – cppcoder Jun 16 '14 at 17:22
1

@JoBe that is a common early mistake with C++ programmers: to seem to notice a pattern, and then start relying on that pattern. – Drew Dormann Jun 16 '14 at 17:29
I see. But it really looks like `int array [5] = {};` , doesn't it? Ah well, encountering errors/mistakes is the only way to really learn, I guess – Jo Mo Jun 16 '14 at 17:31
http://www.slideshare.net/olvemaudal/deep-c – dwerner Jun 16 '14 at 17:53
Dynamic storage can be _value-initialised_ though, granted, you have to write `()` in order to do that. If you call that "being initialized by you" then fine, though I don't. :) – Lightness Races in Orbit Jun 16 '14 at 18:28

Dynamic memory allocation has undesired output

2 Answers2

Linked