CODEWITHSUNDEEP
c++
Southee Rocks
Southee Rocks

Reputation: 183

Dynamic memory allocation...how about this type of inititlization?

To create an integer on heap and initialize it to a value 5, we do:

int* a = new int(5);

To create an array of 5 integers on the heap, we do:

int* a = new int[5];

But, if we want to create an array of 5 integers and initialize each of them to 10 in one single instruction, is it possible?

To make things more interesting, let us say that the array size will only be known at run time. How about then?

Also, I know this is a very trivial question, but I'm making this transition from Java and get confused at times with C++, so... if not initialized during declaration, then unlike in Java, C++ primitive data types are not initialized with default values, and contain garbage values, right?

But someone told me that if they are declared as global variables, then they are initialized to default values like in Java...is that true as well? Why?

Upvotes: 0

Views: 58

Answers (6)

R Sahu
R Sahu

Reputation: 206577

This works for me with g++ 4.8.2.

#include <iostream>

int main()
{
   int* a = new int[5]{10, 10, 10, 10, 10};
   for ( int i = 0; i < 5; ++i )
   {
      std::cout << a[i] << " ";
   }
   std::cout << std::endl;
}

Output:

10 10 10 10 10

Update, in response to OP's comment

When you use 

std::vector<int> v(5, 10);

the constructor of std::vector used is:

vector( size_type count,
        const T& value,
        const Allocator& alloc = Allocator());

Let's say you have a class

class MyClass
{
    public:
       MyClass(int ) {}
};

You can construct a std::vector<MyClass> using:

std::vector<MyClass> v(10, MyClass(50));

or

std::vector<MyClass> v(10, 50);

In the second case, the compiler knows how to implicitly construct a temporary MyClass object given the argument 50 alone. But either way, a temporary MyClass object is being passed to the vector, and that is OK because the argument type of that parameter is const MyClass&, which can bind to a temporary object.

Upvotes: 0

vincentp
vincentp

Reputation: 1433

Use std::array if the size is known at compile-time:

std::array<int, 5> myArray = { 1, 2, 3, 4, 5 };

Which is RAII-conform and safe. You just have to include <array> and <initializer_list>. In other cases, use std::vector.

Upvotes: 0

Soumiruzu
Soumiruzu

Reputation: 1

std::vector has a constructor where you can specify the initial size and initial value:

std::vector<int> an_array(size, init_value);

If you want to use a dynamic array using new[], you have to assign the initial value to each element:

int* array = new a[size];

for(int i = 0; i < size; ++i)
    array[i] = init_value;

...

delete[] array;

Upvotes: 0

Remy Lebeau
Remy Lebeau

Reputation: 595971

No, it is not possible to allocate an array with new[] and specify an initial value for the array elements. You have to fill in the array after the allocation is finished, eg:

int count = 5;
int* a = new int[count]; 
for (int i = 0; i < count; ++i)
    a[i] = 10;
...
delete[] a;

That is not very C++-ish. You could use std::fill() to get rid of the loop, at least:

int count = 5;
int* a = new int[count]; 
std::fill(a, a+count, 10);
...
delete[] a;

A better option is to switch to a std::vector instead, which has a constructor that does exactly what you are looking for:

std::vector<int> a(5, 10); // create 5 elements initialized to value 10

Upvotes: 0

6502
6502

Reputation: 114481

C++ is a very complex language, with many different (even contradicting) goals.

One of the ideas behind it was that you should not pay in efficiency what you don't need and this is what is behind the concept of uninitialized values.

When you write

int x;

the variable x is initialized if it's at global/namespace scope and instead is not initialized when the definition is in a local scope.

This happens not because who designed C is crazy (of course an initialized value is better) but because initialization at global/namespace scope is free from an efficiency point of view as it's done compile/link/loading time, not at runtime.

Initializing a variable in local scope instead has a cost (small, but non-zero) and C++ inherited from C the idea that shouldn't pay for it if you don't need it, thus if you want your variable initialized to any value simply says so with:

int x = 42;

Note however that an uninitialized variable is not simply "containing a garbage value", it's uninitialized and you are not allowed to read its content as such an operation is "undefined behavior".

There are platforms in which just reading the content of an uninitialized variable may crash ("trap representations": for example hardware with dedicated registers for pointers in which just placing an invalid address in a register - not doing anything with it - provokes an hardware exception).

Upvotes: 0

rmccabe3701
rmccabe3701

Reputation: 1468

I prefer:

std::vector<int> a = {10,10,10,10,10};

Upvotes: 2

Related Questions