Thread: Problem with new. Please help.

Remember one thing - dynamic variables are never initialized by the compiler. Therefore it is good practice to first assign them a value, or your calculations may not come out right. There are two ways of doing this :

dp = new double;
*dp = a;

or

dp = new double(a);

where a is the initial value. I personally recommend the second version as it is more suggestive and also more compact.
...
...
Arrays allocated in the heap are similar to those allocated in the data or stack segments, so we may access an arbitrary element using the indexing operator []. For example the next loop initializes each element of the array to zero :

for (int i = 0; i < 100; ++i)
table[i] = 0;

Bad news is C++ does not provide any method of initializing heap arrays as you would an ordinary dynamic variable, so we have to do it ourselves using a loop similar to the one above. The following line will generate errors at compilation :

table = new int[100](0);

http://www.codersource.net/c++_dynam...llocation.aspx

From C++ Primer, Fourth Edition By Stanley B. Lippman, Josée Lajoie, Barbara E. Moo

4.3. C-Style Character Strings

... ...
... ...

Dynamic Arrays of const Objects

If we create an array of const objects of built-in type on the free store, we must initialize that array: The elements are const, there is no way to assign values to the elements. The only way to initialize the elements is to value-initialize the array:

// error: uninitialized const array
const int *pci_bad = new const int[100];
// ok: value-initialized const array
const int *pci_ok = new const int[100]();



It is possible to have a const array of elements of a class type that provides a default constructor:

// ok: array of 100 empty strings
const string *pcs = new const string[100];



In this case, the default constructor is used to initialize the elements of the array.

Of course, once the elements are created, they may not be changedwhich means that such arrays usually are not very useful.

Code:

          // ok: value-initialized const array
          const int *pci_ok = new const int[100]();

These code fails in msvc++6 and dev-c++4, but successes in g++3.2. And in g++3.2, the elements of the array are initialized to 0. I guess in newly standard, the dynamically allocated array is initialized when adding '()' following the bracket pair.

Originally Posted by hk_mp5kpdw

So, you just have some extra code, like a loop or something to initialize your array after you've allocated it.

No. I have not add a loop or anything else to initialize the array.
And note that this code allocates dynamic arrays of const objects:

Code:

const int *pci_ok = new const int[100]();

Here is my code. g++3.2 compiles it successfully. But in msvc++6 and dev-c++4, this code cannot be compiled.

Code:

#include <iostream>
#include <cstddef>

using std::cout;
using std::endl;
using std::cin;

int main(void)
{
	const int *pci_ok = new const int[10](); // note that here add '()' after the bracket pair
	for ( size_t i = 0; i < 10; i++ ) {
		cout << pci_ok[i] << ' ';
	}
	cout << endl;

    cin.get();
    return 0;
}

You misunderstood me. Maybe that's because of my poor English. I'll try my best to express myself.

The following quoted sentences are from C++ Primer, 4th Edition

we can value-initialize the elements by following the array size by an empty pair of parentheses:

int *pia2 = new int[10] ();

The parentheses are effectively a request to the compiler to value-initialize the array, which in this case sets its elements to 0.

Does the quoted sentences mean that it's in C++ Standard that each element in the dynamically allocated array should be initialized to 0 when we write int *pia2 = new int[10] (); ?

In g++, the elements are initialized to 0, but not in msvc++6 or dev-c++4.

My question is: int *pia2 = new int[10] (); is in C++ Standard to initialize the elements to 0 or is implementation-dependent?

I guess it's a newly standard that we can write int *pia2 = new int[10] (); to initialize the elements to 0, because in C++ Primer, 4th Edtion, the author say that we can define Dynamic Arrays of const Objects.

From C++ Primer

If we create an array of const objects of built-in type on the free store, we must initialize that array: The elements are const, there is no way to assign values to the elements. The only way to initialize the elements is to value-initialize the array:

// error: uninitialized const array
const int *pci_bad = new const int[100];
// ok: value-initialized const array
const int *pci_ok = new const int[100]();

Of course, once the elements are created, they may not be changed which means that such arrays usually are not very useful.

Because const object must be initialized when it is defined. So if it's possible to define Dynamic Arrays of const Objects, then the dynamic array of const objects must be initialized when it is defined. That's to say there is a way to initialize dynamic array. C++ Primer says that we can use int *pia2 = new int[10]() to initialize each element of the dynamic array to 0. This code will work in g++3.2 and initialize the elements to 0. But in msvc++6 and dev-c++4, the elements are left uninitialized. Is it because msvc++6 and dev-c++4 are too old so that they don't support this newly standard? Or is it because int *pia2 = new int[10]() is never a c++ standard to initialize the elements to 0.

Sorry about my poor English. Could anyone understand my question now?

This code will work in g++3.2 and initialize the elements to 0. But in msvc++6 and dev-c++4, the elements are left uninitialized. Is it because msvc++6 and dev-c++4 are too old so that they don't support this newly standard? Or is it because int *pia2 = new int[10]() is never a c++ standard to initialize the elements to 0.

If you are going to have lots of these types of questions, then you can buy a copy of the C++ standard and look it up. There are several people on this forum that have copies and can look it up for you. In the future, if you have a standards question, put that in the topic of the post:

Question about C++ standard?