C++ 常量对象的复制构造函数

我有一个下面的班级

class foo
{
    int *arr; // arr holds numbers
    int sz; // size of array
    public:
    // Suppose I have made default and 1 parameter c'tor
    foo(const foo &f)
    {
        sz = f.sz;
        arr = new int[sz];
        for(int i=0;i<sz;i++)
            arr[i]=f.arr[i];
    }
};

int main()
{
    foo x(5); //5 is size of array
    const foo y = x; //doesn't work as I haven't initialized in member-initialization list, but how to write for loop in member initialization list ?
}  

class-foo
{
int*arr；//arr保存数字
int sz；//数组的大小
公众：
//假设我设置了默认值和1个参数c'tor
富（恒富及富）
{
sz=f.sz；
arr=新整数[sz]；
对于（inti=0；i您可以在本例中使用
std:：vector
，无论如何

通常，我会创建一个私有静态方法来执行分配和复制。然后可以使用初始化列表：

static int* CloneInts(const foo& f) {
    int* ints = new ...
    ...copy them from @a f.arr...
    return ints;
}

那么您的init列表如下所示：

foo(const foo& f) : arr(CloneInts(f)), sz(f.sz) {

您是否尝试过直接使用复制构造函数构造它

constfooy（x）；
你应该澄清你的问题，因为问题中的问题实际上并不存在

const foo y=x；
行将编译并使用该复制构造函数。在构造函数完成之前，正在构造的const对象不是“const”。因此，即使正在构造的对象是const，也允许构造函数主体修改该对象

还要注意，示例中的循环甚至没有修改任何常量-因为数组是动态分配的，即使对象本身不是，这些数组元素也是可修改的。例如，
arr
指针在ctor完成后不可修改，但
arr[0]
仍然是可修改的

请尝试以下操作，以查看这两个要点的作用：

#include <stdio.h>
#include <algorithm>

class foo
{
    int *arr; // arr holds numbers
    int sz; // size of array
    public:
    foo() : arr(0), sz(0) { puts("default ctor");}
    foo(int x) : arr(0), sz(x) {
        puts( "int ctor");
        arr = new int[sz];
        for(int i=0;i<sz;i++)
            arr[i]=0;
    }

    foo(const foo &f)
    {
        puts("copy ctor");
        sz = f.sz;
        arr = new int[sz];
        for(int i=0;i<sz;i++)
            arr[i]=f.arr[i];
    }

    ~foo() {
        delete [] arr;
    }

    foo& operator=(const foo& rhs) {
        if (this != &rhs) {
            foo tmp(rhs);
            std::swap( arr, tmp.arr);
            std::swap( sz, tmp.sz);
        }

        return *this;        
    }

    void update() const {
        for(int i = 0; i < sz; i++) {
            arr[i] = arr[i] + 1;
        }
    }

    void dump() const {
        for(int i = 0; i < sz; i++) {
            printf("%d ", arr[i]);
        }
        puts("");
    }
};

int main()
{
    foo x(5); //5 is size of array
    const foo y = x; 

    y.dump();
    y.update(); // can still modify the int array, even though `y` is const
    y.dump();
}  

#包括
#包括
福班
{
int*arr；//arr保存数字
int sz；//数组的大小
公众：
foo（）：arr（0），sz（0）{put（“默认向量”）；}
foo（intx）：arr（0），sz（x）{
看跌期权（“int ctor”）；
arr=新整数[sz]；
对于（int i=0；i）你的行
foo x（5）；
不会用你展示的代码编译，没有带
int
参数的构造函数。你对“1参数c'tor”的评论是指在你的真实代码中确实存在的
foo（int）
构造函数吗？我把它理解为应用于复制构造函数。你说“它不工作”是什么意思“？如果您提供构造函数
explicit foo（int）
，它将编译。我已经创建了参数化的c'tor，尽管我没有在这里编写它们。假设它们存在。“不起作用”。它是如何工作的；您收到了什么错误消息？@HappyMittal您描述的错误与复制构造函数无关。它与
运算符[]有关
，显然你也为你的类定义了它，它不是一个
const
-方法。事实上，我试图模仿std:：vector，而不是使用它：D你能告诉我在初始化列表中如何使用静态方法吗？我没有理解你。不。它将运行你在副本构造函数中的确切代码。它将分配一个新的
int
array并将源
foo
中的值复制到它。那么为什么我们需要复制c'tor？我认为我们需要复制c'tor的原因是编译器会逐位复制。您可以实现自己的复制构造函数来覆盖编译器生成的代码。这里有些混乱：没有复制构造函数，编译器会生成它jvstech的建议是避免编译器调用默认构造函数（后跟赋值运算符）的可能性。