标签: copy-constructor

由于我的一些代码需要在不同类型的矩阵之间进行隐式转换(例如Matrix<int>to Matrix<double>),我定义了一个模板化的复制构造函数Matrix<T>::Matrix(Matrix<U> const&)而不是标准Matrix<T>::Matrix(Matrix<T> const&):

template <typename T> class Matrix {
public:
    // ...
    template <typename U> Matrix(Matrix<U> const&);
    // ...
private
    unsigned int m_rows, m_cols;
    T *m_data;
    // ...
};

通过向复制构造函数添加适当的类型转换,此方法可以在不同类型的矩阵之间完美地转换.令人惊讶的是,在一个简单的复制构造函数可以运行的情况下,它会因malloc错误而失败:where U == T.果然,使用默认Matrix<T>::Matrix(Matrix<T> const&)签名重载复制构造函数可以解决问题.

这是一个糟糕的解决方案,因为它导致复制构造函数代码的批量复制(字面意思是未更改的复制和粘贴).更重要的是,我不明白为什么malloc没有重复代码会出现双重自由错误.此外,为什么template <typename T> template <typename U>这里需要极其冗长的语法而不是标准,而且更简洁template <typename T, typename U>？

模板化方法的完整源代码,在Mac OS 10.5上使用G ++ v4.0.1编译.

template <typename T> template <typename U> Matrix<T>::Matrix(Matrix<U> const& obj) {
    m_rows = obj.GetNumRows();
    m_cols …

我创建了一个简单的测试用例,展示了我在一个更大的代码库中注意到的奇怪行为.这个测试用例如下.我依靠STL Map的"[]"运算符来创建指向这种结构的映射中的结构的指针.在下面的测试用例中,线...

TestStruct *thisTestStruct = &testStructMap["test"];

...给我指针(并在地图中创建一个新条目).我注意到的奇怪之处在于,这一行不仅会导致地图中的新条目被创建(因为"[]"运算符),但由于某种原因,它会导致结构体的析构函数被多次调用两次.我显然错过了一些东西 - 非常感谢任何帮助!谢谢!

#include <iostream>
#include <string>
#include <map>

using namespace std;
struct TestStruct;

int main (int argc, char * const argv[]) {

    map<string, TestStruct> testStructMap;

    std::cout << "Marker One\n";

    //why does this line cause "~TestStruct()" to be invoked twice?
    TestStruct *thisTestStruct = &testStructMap["test"];

    std::cout << "Marker Two\n";

    return 0;
}

struct TestStruct{
    TestStruct(){
        std::cout << "TestStruct Constructor!\n";
    }

    ~TestStruct(){
        std::cout << "TestStruct Destructor!\n";
    }
};

上面的代码输出以下内容......

/*
Marker One
TestStruct Constructor!             //makes sense …

我刚刚意识到这个程序编译并运行(gcc版本4.4.5/Ubuntu):

#include <iostream>
using namespace std;

class Test
{
public:
  // copyconstructor
  Test(const Test& other);
};

Test::Test(const Test& other)
{
  if (this == &other)
    cout << "copying myself" << endl;
  else
    cout << "copying something else" << endl;
}

int main(int argv, char** argc)
{
  Test a(a);              // compiles, runs and prints "copying myself"
  Test *b = new Test(*b); // compiles, runs and prints "copying something else"
}

我想知道为什么这个甚至可以编译.我假设(就像在Java中)参数在调用方法/构造函数之前被评估,所以我怀疑这个案例必须由语言规范中的一些"特殊情况"涵盖？

问题:

1. 有人可以解释一下(最好是参考规范)吗？
2. 允许这个的理由是什么？
3. 它是标准的C++还是gcc特有的？

编辑1:我刚刚意识到我甚至可以写作 int i = i;

编辑2:即使有-Wall …

灵感来自这个问题.

通常,创建复制构造函数和赋值运算符的原因private是使类不可复制,以便只能创建和销毁对象,但不能复制 - 大多数情况下,因为复制它们没有任何意义.在这种情况下,复制构造函数和赋值运算符都已生成private 且未实现 - 如果类不可复制,则无人应复制.

复制构造函数和赋值运算符是否需要private同时具有有意义的实现？

可能重复:
std :: string x(x);

class A {};

int main() {

    A a(a);
}

这编译.

gcc(GCC)4.7.2 20120921(Red Hat 4.7.2-2)
g++ -o main main.cpp -Wall -w -ansi

我没有收到任何警告.

为什么这似乎是有效的C++？
这是在标准中的任何地方提到的吗？
是否有可以为gcc报告此警告标志？

当类具有成员数据时,数据随机结束.
例:

#include <iostream>

class A {

public:
    int i;
    A() : i{6} {}
};

int main() {

    A a(a);
    std::cout << a.i << '\n';
}

输出:-482728464

这里发生了什么？另外,我怎么能防止自己意外地这样做？ - 是否有可能使其成为编译器错误？

Java是否具有C++的默认复制构造函数？如果它有一个 - 如果我明确地声明另一个构造函数(不是复制构造函数),它是否仍然可用？

真实的例子显然要长得多,但这总结了我的问题:

class Object
{
 int mInt1,mInt2;
 Object::Object();
 Object::Object(int param1);
 Object::Object(int param1, int param2);
};
Object::Object(){}
Object::Object(int param1):mInt1(param1){}
Object::Object(int param1, int param2):mInt1(param1),mInt1(param2){}

然后在主要:

if (type1){
  Object instance(param1);
}
else{
  Object instance(param1,param2);
}
// do stuff with instance

哎呦!这不起作用,实例超出了后续程序的范围.

Object instance;
if (type1){
  instance = Object(param1);
}
else{
  instance = Object(param1,param2);
}
// do stuff with instance

但是现在我遇到了麻烦,因为我没有定义复制构造函数.我真的不想写一个拷贝构造函数,因为我的实际类有几十个成员,其中许多是非基本类型,可能需要更多的工作来复制.

具体来说,我得到了

main.cpp: error: use of deleted function ‘Object& Object::operator=(Object&&)’
         instance = Object(param1);
                  ^
note: ‘Object& Object::operator=(Object&&)’ is implicitly deleted because the default definition would …

当类显式声明复制操作(即复制构造函数或复制赋值运算符)时,不会为该类声明移动操作.但是当一个类显式声明一个移动操作时,复制操作被声明为已删除.为什么存在这种不对称？为什么不指定如果声明移动操作,则不会声明复制操作？据我所知,不存在任何行为差异,也不需要对移动和复制操作进行不对称处理.

[对于喜欢引用该标准的人,在12.8/9和12.8/20中指定缺少具有复制操作声明的类的移动操作声明,并且具有移动操作声明的类的已删除复制操作在12.8 /中指定7和12.8/18.]

我有一个类A(来自我无法控制的库),有一个私有拷贝构造函数和一个clone方法,以及一个B派生自的类A.我想实现clone的B为好.

天真的做法

#include <memory>

class A { // I have no control here
  public:
    A(int a) {};

    std::shared_ptr<A>
      clone() const
      {
        return std::shared_ptr<A>(new A(*this));
      }

  private:
    A(const A & a) {};
};

class B: public A {
  public:
    B(int data, int extraData):
      A(data),
      extraData_(extraData)
    {
    }

    std::shared_ptr<B>
    clone() const
    {
      return std::shared_ptr<B>(new B(*this));
    }

  private:
    int extraData_;
};

int main() {
  A a(1);
}

但是,失败了,因为复制构造函数A是私有的:

main.cpp: …

在下面的代码中,"情境1" 在所有测试的编译器上按预期工作,但"情况2"似乎根据所使用的编译器而表现不同.

作为示例,MSVC使sit1和sit2产生相同的结果,但是当使用gcc/clang和libstdc ++时,修改发生在原始字符串和它的副本(有点像COW字符串),即使我正在使用C +构建+11开关.

#include <iostream>
#include <string>

int main() {

   // situation 1
   {
      std::string x0 = "12345678";
      std::string x1 = x0;

      char* ptr = &x0[0] + 3;

      (*ptr) = ' ';

      std::cout << "1. x0: " << x0 << "\n";
      std::cout << "1. x1: " << x1 << "\n";

      if ((&x0[0]) == x0.data()) std::cout << "1. ptrs are equal\n";

   }

   // situation 2
   {
      std::string x0 = "12345678";
      std::string x1 = x0; …