copy-constructor

I haven't ever heard it's possible, but asking with the hope that it might. For a class with many more member variables than this: class A { public: SomeOtherClass* s; int i; int j; A() {} A(const A& soc): s(soc.s->Clone()), i(soc.i), j(soc.j) {} }; I always have to remember that if I add another variable int k to the class, I'll also have to add it in the initialization list k(soc.k) and sometimes in the destructor too. I've had to add/remove member variables so many times and it's really annoying to forget about the copying in the initialization list and finding the omission much much later

My understanding is that a move constructor is called if it exists when we return a local object from a function. However, I ran into a situation where the copy constructor was called instead, as shown in the following example in function foo2() . Why did that happen? #include <cstdio> #include <memory> #include <thread> #include <chrono> class tNode { public: tNode(int b = 10) { a = b; printf("a: %d, default constructor %s() is called at %s:%d \n", a, __func__, __FILE__, __LINE__); } tNode(const tNode& node) { a = node.a; printf("a: %d, copy constructor %s() is called at %s:%d \n", a, __func_

It's possible to make a local copy of an iostream object, using rdbuf and copyfmt . This allows formatting changes to be locally scoped: std::ostream & operator << ( std::ostream & os, foo const & smth ) { cloned_ostream cs( os ); cs << std::hex << smth.num; // os is not switched to hexadecimal, which would be a confusing side-effect return os; } Why don't the stream classes provide copy constructors to do this? Have relevant C++ best practices changed since they were designed as non-copyable? Copying and moving are value-semantic operations. To define them, you first have to decide what

Possible Duplicate: Why copy constructor is not called in this case? Consider the sample program below: #include <iostream> using namespace std; class sample { private: int x; public: sample(int a=0) : x(a) { cout << "default ctor invoked\n"; } sample(const sample& obj) { cout << "copy ctor invoked\n"; } }; int main() { sample s2 = sample(20); //Line1 sample s3 = 20; //Line2 return 0; } In Line1 , first the constructor of sample class is invoked explicitly with the argument 20. Then i expected the copy constructor to be invoked to initialize s2. In Line2, first the constructor of sample class

Regarding to the requirement for C++ stl container element, the standard says: the element type should be CopyConstructible, and there is a table for CopyConstructible requirements. Also by various books (Josuttis, etc.), the generated copy should be "equivalent to" the source. I think I need some clarity here. What is exactly "equivalent to"? Also I am a bit confused with the relation between the "CopyConstructible" and the "deep/shallow copy". In general, a copy constructor is either shallow copy or deep copy. So which one applies to the "CopyConstructible", and which does not? Thanks for

After reading about copy constructors and copy assignment operators in C++, I tried to create a simple example. Though the below snippet apparently works, I am not sure whether I am implementing the copy constructor and copy assignment operator the right way. Could you please point out if there are any mistakes/improvements or a better example to understand the relevant concepts. class Foobase { int bInt; public: Foobase() {} Foobase(int b) { bInt = b;} int GetValue() { return bInt;} int SetValue(const int& val) { bInt = val; } }; class Foobar { int var; Foobase *base; public: Foobar(){}