copy-constructor

Given struct Foo { Foo(Foo&) {} }; std::is_copy_constructible<Foo>::value is false Foo has valid copy-constructor: From draft n4659: 15.8.1 Copy/move constructors [class.copy.ctor] 1 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 (11.3.6). [Example: X::X(const X&) and X::X(X&,int=1) are copy constructors. but is_copy_constructible tests is_constructible_v<T, const T&> ( const ) according to the standard.

I've got the following class-structure: class A{ A(){} A(const A& src){} }; class B : virtual A { B():A(){} B(const B& src):A(src){} }; class C : virtual A { C():A(){} C(const C& src):A(src){} }; class D : virtual B, virtual C { D():B(),C(){} D(const D& src):B(src),C(src){} }; This gives me the warning: In copy constructor ‘D’: warning: base class ‘A’ should be explicitly initialized in the copy constructor Which I dont unterstand. The Copy -Constructor of D calls the copy-ctor of B which calls the copy-ctor of A. Why does it want me to call the copy-ctor of A in D? If I would do so, wouldnt

In short: is there some way I can modify a class definition such that it fails to compile at the point of use of a copy constructor no matter where it's used? I have a very large project and was cleaning up some class definitions. There's a class that I explicitly don't want to use copy constructors on (let's ignore why that is for the sake of this discussion), and in the interest of safety, I figured I'd just define the copy constructor as private and not actually implement it... that way it would throw a compile error if I tried to use it anywhere. Lo and behold, it compiles fine, but I have

Like this: public class remoteStatusCounts : RemoteStatus { public int statusCount; public remoteStatusCounts(RemoteStatus r) { Type t = r.GetType(); foreach (PropertyInfo p in t.GetProperties()) { this.property(p) = p.GetValue(); //example pseudocode } } } The example is a bit simple (it's from the Jira API - RemoteStatus has 4 properties), but imagine the base class had 30 properties. I don't want to manually set all those values, especially if my inherited class only has a couple of extra properties. Reflection seems to hint at an answer. I saw at Using inheritance in constructor (publix X

My current implementation uses lots of copy constructors with this syntax MyClass::Myclass(Myclass* my_class) Is it really (functionnaly) different from MyClass::MyClass(const MyClass& my_class) and why? I was adviced that first solution was not a true copy constructor. However, making the change implies quite a lot of refactoring. Thanks!!! It's different in the sense that the first isn't a copy constructor, but a conversion constructor. It converts from a MyClass* to a MyClass . By definition, a copy-constructor has one of the following signatures: MyClass(MyClass& my_class) MyClass(const

Consider the below code: #include<iostream> using namespace std; class A { public: A() {cout << "1";} A(const A &obj) {cout << "2";} }; class B: virtual A { public: B() {cout << "3";} B(const B & obj) {cout<< "4";} }; class C: virtual A { public: C() {cout << "5";} C(const C & obj) {cout << "6";} }; class D:B,C { public: D() {cout << "7";} D(const D & obj) {cout << "8";} }; int main() { D d1; cout << "\n"; D d(d1); } The output of the program is below: 1357 1358 So, for line D d(d1) the copy constructor of D class is bein called. During inheritance we need to explicitly call copy constructor

Before continue reading this, please read Is there a difference in C++ between copy initialization and direct initialization? first, make sure you understand what it is talking about. I'll summarize the rule here first (read standard n3225 8.5/16, 13.3.1.3, 13.3.1.4, and 13.3.1.5), 1) For direct initialization, all constructors will be considered as the overloading set, the overloading resolution will select the best one according to the overloading resolution rules. 2) For copy initialization and the source type is the same as destination type or derived from destination type, the rule is as

#include <iostream> #include <string> #include <array> class C { private: std::string a; std::string b; std::string c; public: C(std::string a_, std::string b_, std::string c_) : a{a_},b{b_},c{c_} {} ~C(){}; C(const C&) =delete; C(const C&&) =delete; const C& operator=(const C&) =delete; const C& operator=(const C&&) =delete; }; std::array<C,2> array = {C("","",""),C("","","")}; int main() {} this won't compile (Android Studio with NDK and clang) with a "call to deleted constructor of c" error. I know that I can e.g. use a std::vector and emplace_back() to construct an element directly inside

I thought in theory the answer to this question was yes. However, in practice, my compiler (VS2010) does not seem to complain in the following situation: I have an abstract base class providing some common interface (yet having no data members) and various sub and subsubclasses derived from it. class Base { public: Base() {} virtual ~Base() {} virtual void interfaceFunction1() = 0; virtual void interfaceFunction2() = 0; private: Base(const Base&); // all derived classes should be uncopyable Base& operator=(const Base&); // no data members }; My compiler found it unproblematic to even implement