Just a quick question. In this example:
is the constructor of MyClass called 10 times (assuming it has a default constructor)? or only the memory is allocated?Code:int main() { MyClass a[10]; }
How about something like this:
If the constructors are called, wouldn't that make the allocation of an array and construction of the vector O(n)? (assuming the constructor itself is O(1) ).Code:int main() { std::vector<MyClass> v(10); }
Thank you
Both call the default constructor 10 times.
Yes, creation and initialization of the array would be O(n).
I see. Thank you.
As part of simple experimentation with the language you could have easily found that out by outputting something in the default constructor:Originally Posted by cyberfish
You then would have seen something like the following when you ran the program:Code:class MyClass { public: MyClass() { std::cout << "Constructor called." << std::endl; } };
Code:Constructor called. Constructor called. Constructor called. Constructor called. Constructor called. Constructor called. Constructor called. Constructor called. Constructor called. Constructor called.
"Owners of dogs will have noticed that, if you provide them with food and water and shelter and affection, they will think you are god. Whereas owners of cats are compelled to realize that, if you provide them with food and water and shelter and affection, they draw the conclusion that they are gods."
-Christopher Hitchens
What this fails to reveal, however, is that an optimizing compiler WILL omit the constructor calls, if the object is POD and has a trivial constructor, or if the compiler can otherwise prove that the constructors don't need to be called.You then would have seen something like the following when you ran the program:
Code:Constructor called. Constructor called. Constructor called. Constructor called. Constructor called. Constructor called. Constructor called. Constructor called. Constructor called. Constructor called.
In other words, the very act of printing the message from the constructor forces the compiler to make sure it is called. If you have a vector of simple structs holding POD, you don't pay a O(n) price to construct the vector.
Hmm.. that is interesting to know. My next question would be, is it possible to force the compiler to not call the constructor. (in pure C++, without using malloc and friends)What this fails to reveal, however, is that an optimizing compiler WILL omit the constructor calls, if the object is POD and has a trivial constructor, or if the compiler can otherwise prove that the constructors don't need to be called.
In other words, the very act of printing the message from the constructor forces the compiler to make sure it is called. If you have a vector of simple structs holding POD, you don't pay a O(n) price to construct the vector.
Yes, by making sure that the constructor doesn't do anything, and making the constructor known to the compiler before the code that "uses" the constructor, you can (for most compilers, most of the time) make the constructor call go away.
Of course, the compiler can't avoid calling the constructor if the constructor does something "useful". It may inline the constructor in this case, but it can not avoid using the constructor, as that would be "Breaking the object rules".
--
Mats
Compilers can produce warnings - make the compiler programmers happy: Use them!
Please don't PM me for help - and no, I don't do help over instant messengers.
If you want to ensure there is enough space allocated but not actually create the objects, then use reserve:Then, when you are ready use push_back to add constructed objects.Code:int main() { std::vector<MyClass> v; v.reserve(10); }
Is there a reason you are so concerned about this?
That must be using a placement new somewhere under the hood...
Not really. Just out of curiosity =).Is there a reason you are so concerned about this?
Thanks for the replies.
