Printable View
Um, you gave a code snippet without explaining how does it support your claim that "thats very untrue. there is no point in initializing it". Now you throw an ad hominem attack against me. I do not see how is it that I have to "take a forum tutorial and how to read a discussion tutorial".Quote:
take a forum tutorial and how to read a discussion tutorial i also suggest you take a tutorial on how to have common sense. good luck googling.
If there is no point in initializing it, what point is there in allocating it?Quote:
Originally Posted by Mitsukai
also take a how to read a C++ comment tutorial
to have an dynamic array ofcourse. initialization shuld be done by the user not by the implention. and can cost serious CPU cycles decreasing a computers life time unnesesary.Quote:
Originally Posted by RoboTact
I have read your source comments, of course, but I find them inadequate in explaining your position.Quote:
also take a how to read a C++ comment tutorial
Does my example not show how one can pretty much delay initialisation?Quote:
to have an dynamic array ofcourse. initialization shuld be done by the user not by the implention. and can cost serious CPU cycles decreasing a computers life time unnesesary.
The thing is, if you store objects in a vector, then the objects should have some value, i.e. they must be initialised. The equivalent of what the original poster was asking for is to reserve the space, and then insert values later.
And in this case allocation without initialization IS implementation detail. And laserlight showed how to advise implementation on that.Quote:
Originally Posted by Mitsukai
If vectors did not initialize all of their elements to zero, you would
run into the same problems you do when you don't initialize an array.
IMO, all arrays and vectors should be initialized, whether by the user
or by it's implementation automatically. If they aren't then you run the
risk of accidentally using some garbage value stored in one of the
uninitialized elements in a calculation.
An example would be this..
In the first example, the sum will be unaffected because all of the arrayCode:#include <vector>
#include <iostream>
using namespace std;
int main(){
int sum = 0;
int intArray1[10];
for ( int i=0; i < 10; i++ )
intArray1[ i ] = 0;
intArray1[0] = 1;
intArray1[1] = 2;
intArray1[2] = 3;
intArray1[3] = 4;
intArray1[4] = 5;
for( int i=0; i < 10; i++ )
sum += intArray1[ i ];
cout << sum << endl;
//*******************************
sum = 0;
int intArray2[10];
intArray2[0] = 1;
intArray2[1] = 2;
intArray2[2] = 3;
intArray2[3] = 4;
intArray2[4] = 5;
for( int i=0; i < 10; i++ )
sum += intArray2[ i ];
cout << sum << endl;
cin.get();
return 0;
}
elements were initialized to zero. In the second example, the sum spits
out an incorrect value because the last five elements were left
uninitialized with some garbage values. If your array was huge, say a
million elements, you could easily cause an integer overflow with this.
I think it is worth the performance sacrifice to initialize an array or vector
in order to avoid a great deal of problems later on down the road.
how has this todo with initialisation, it dont.Code:If your array was huge, say a million elements, you could easily cause an integer overflow with this.
so what if you get garbage values? having a array initialised 0 is basicly the same thing. its garbage. its something you will never really work with. its always initialised to something before used. thus making it a double initialisation. Wasting lots of CPU cyclesQuote:
with some garbage values
new calls constructors. they already have a "value". thus making it a triple initialisation. By new, by vector, by user. again wasting lots lots of cpu cycles.Quote:
then the objects should have some value
see post #20...Quote:
And in this case allocation without initialization IS implementation detail
The question hasn't been asked yet.Quote:
Originally Posted by Ujl
Did you time a release (optimized) build, or a debug build? If you timed a debug build, then this whole discussion is pointless.
Regards,
Paul McKenzie
That is if you do not intend to have a zero initialised vector. For example, one could have an int vector of a million 10s:Quote:
so what if you get garbage values? having a array initialised 0 is basicly the same thing. its garbage. its something you will never really work with.
Basically, if you choose to use the constructor that accepts an integer stating the number of elements the vector should contain, you get a vector with that number of elements, initialised to whatever value you set, or some zero or default value if none is given.Code:std::vector<int> x(1000000, 10);
Constructors perform default initialisation.Quote:
new calls constructors. they already have a "value".
That is correct. However, if you have 0 there's advantage of determinism of incorrect behaviour if you'll stumble upon one. And anyway you shouldn't use either method: values you don't work with shouldn't be accessible at all. vector with reserved part gives both advantages.Quote:
Originally Posted by Mitsukai
You really should cool down.Quote:
Originally Posted by Mitsukai
that is still garbage. you know you initialised it to 10.Quote:
Originally Posted by laserlight
so?Quote:
Originally Posted by laserlight
I'm glad you did -- it shows why usage of standard classes such as vector are important in proper, bug-free developmentQuote:
Originally Posted by aewarnick
Your class lacks a copy constructor, and an assignment operator. It also lacks the proper overload of operator [] (there should be two overloads, not one). The memcpy() does not work if the object is non-POD, i.e.
Even for int, this simple code snippet causes memory corrution when main() terminatesCode:#include <string>
//...
aArr<std::string> s; // error if used for this type
I could go onto other issues with it, but the lack of copy constructor and assignment operator are big problems.Code:int main()
{
aArr<int> a1(10);
aArr<int> a2 = a1; // pointers point to same memory
} // your dead here
Regards,
Paul McKenzie
Do you know how to read? Did you even look at my example? If you did,Quote:
how has this todo with initialisation, it dont.
then you would understand it has everything to do with initialization.
If in my example, the array had a million elements which were
uninitialized and you attempted to sum them you would more
than likely cause an integer overflow because they contain garbage
values whose values are unknown.
If it were initialized to all zeroes, then your calculation wouldn't
be affected at all. Likewise if you wanted to multiple all of the elements
together and you initialized all of the elements to one, your results
wouldn't be affected.
There is a simple reason reason to initialize an array, and that's becauseQuote:
so what if you get garbage values? having a array initialised 0 is basicly the same thing. its garbage. its something you will never really work with. its always initialised to something before used. thus making it a double initialisation. Wasting lots of CPU cycles
if left uninitialized you just don't know what the elements contain. This
opens up the risk to negatively affecting a calculation down the road.
It is not going to waste CPU cycles. The array is allocated in memory
and whatever values those particular places in memory contain at that
moment in time the array will contain. By saying this is a double
initialization, you are implying that simply creating an array takes O(N) time.
No, it doesn't. By initializing the elements to some value which you know
guarantees the "safety" issue of your program in which you assure that
it is not going to, or at least not likely to, make a calculation mistake.
Gah, you always ask the right questions :)Quote:
Did you time a release (optimized) build, or a debug build? If you timed a debug build, then this whole discussion is pointless.
It isnt garbage since in this case the programmer requires a vector of a million 10s.Quote:
that is still garbage. you know you initialised it to 10.