copy-constructor

Can anyone explain the meaning of *p=*q in this C++ code? Is this a copy constructor concept? class A{ //any code } int main(){ A *p=new A(); A *q=new A(); *p=*q; return 0; } Is this a copy constructor concept? No, what you are referring to is a copy assignment concept. Consider this: int* p = new int{9}; int* q = new int{10}; *p = *q; As you can see above, only the value of the variable q which is pointed to is copied. This is the equivalent of the copy assignment for objects. If you were to do this: p = q; Then this would not be a copy assignment, because both int 's point to the same

Consider the following code: #include <iostream> using namespace std; class A { public: int a; A(): a(5) { cout << "Constructor\n"; } A(const A &b) { a = b.a; cout << "Copy Constructor\n"; } A fun(A a) { return a; } }; int main() { A a, c; A b = a.fun(c); return 0; } The output of the above code with g++ file.cpp is: Constructor Constructor Copy Constructor Copy Constructor The output of the above code with g++ -fno-elide-constructors file.cpp is: Constructor Constructor Copy Constructor Copy Constructor Copy Constructor I know Return Value Optimization. My question is which call to copy

$12.8/2 - 'A non-template constructor for class X is a copy constructor if its first parameter is of type X&, const X&, volatile X& or const volatile X&, and either there are no other parameters or else all other parameters have default arguments (8.3.6).106)' So far, I have not come across any example of a situation where there is a need to declare a copy constructor with additional default parameters. Would like to know any real time use of such a copy constructor which take more than one parameter. The old std::basic_string does have one too: basic_string(const basic_string& s, size_type

If the operator= is properly defined, is it OK to use the following as copy constructor? MyClass::MyClass(MyClass const &_copy) { *this = _copy; } If all members of MyClass have a default constructor, yes. Note that usually it is the other way around: class MyClass { public: MyClass(MyClass const&); // Implemented void swap(MyClass&) throw(); // Implemented MyClass& operator=(MyClass rhs) { rhs.swap(*this); return *this; } }; We pass by value in operator= so that the copy constructor gets called. Note that everything is exception safe, since swap is guaranteed not to throw (you have to ensure

I am reviewing the cppreference page on copy constructors here: http://en.cppreference.com/w/cpp/language/copy_constructor I've read the 2 sections regarding implicitly-declared copy constructors and implicitly-defined copy constructors quite a few times but I still don't understand the distinction. Wouldn't an implicitly declared but NOT defined constructor result in linker problems? The rules are very complex. I don't remember there being a distinction in C++03: Either you had a compiler generated copy constructor or you didn't. Can someone explain (in simpler words) what the distinction