将结构复制到具有常量值的数组

Question

我正在尝试替换非常量数组中具有常量值的结构值，但它无法编译:

“Foo”类型的对象无法赋值，因为它的复制赋值运算符已隐式删除

下面是一个例子:

struct Foo {
    const int id;
    int value;
    Foo(): id(-1), value(-1) {}
    Foo(int id): id(id), value(0) {}
};


int main(int argc, const char * argv[]) {
    Foo foos[10];
    foos[0] = Foo(1234);
    return 0;
}

我来自于一个快速的背景，在这里，当它将struct值复制到数组中时，它是有效的。

我试着做一个我认为是拷贝赋值运算符，但是对于常量成员，我试过的也不起作用。

这就是我试图为复制赋值运算符所做的:

    Foo& operator= (Foo newVal) {
        // what do I put here!?
        return *this;
    };

对数组执行memcpy是可行的，但似乎是错误的大锤。

作为C++的新手，我不确定这种流的正确模式是什么。

Answer 1

在C++中，一个对象只能初始化一次。在声明数组时，通过默认构造函数初始化常量成员。然后，尝试通过赋值更改该值

foos[0] = Foo(1234);

这种做法失败了，而且很严重。您可以做的一件事是拥有一个容器，而不是FOO，而是指向FOO的某种指针。因此，您将为指针分配内存，但只有在可能的情况下才会创建实际的对象。例如:

Foo* foos[10]; //here you have only the pointers
foos[0] = new Foo(1234); //OK, the object is inialized here

您可以考虑使用诸如std::unique_ptr之类的智能指针，而不是这里的原始指针。

Answer 2

在初始化const值之后，您永远不能更改它。

从名称id听起来，移动语义是您需要的。与其拥有两个具有相同id的有效对象，还可以在对象之间移动数据，但不能复制数据。

示例:

#include <iostream>
#include <utility>

struct Foo {
    Foo() : id(-1), value(-1) {}                      // default - "invalid" values

    Foo(int id, int value) : id(id), value(value) {} // constructor
    explicit Foo(int id) : Foo(id, 0) {}             // converting ctor, delegating 

    Foo(const Foo&) = delete;                        // no copy construction
    Foo(Foo&& rhs) :                                 // move construction ok
        id(std::exchange(rhs.id, -1)),               // take id, give -1 back
        value(std::exchange(rhs.value, -1))          // take value, give -1 back
    {}
    Foo& operator=(const Foo&) = delete;             // no copy assignment
    Foo& operator=(Foo&& rhs) {                      // move assignment ok
        // give the "moved from" element our id and value and
        // take id and value from the "moved from" element
        std::swap(id, rhs.id);
        std::swap(value, rhs.value);
        return *this;
    }

    int Id() const { return id; }        // only const access
    
    int& Value() { return value; }       // non-const access in non-const context
    int Value() const { return value; }  // const access in const context

private:
    int id;
    int value;
};

int main() {
    Foo foos[2];
    foos[0] = Foo(1234);     // The temporary Foo will have (-1, -1) when it's destroyed
    for(auto& f : foos)
        std::cout << f.Id() << ' ' << f.Value() << '\n';
}

输出:

1234 0
-1 -1

Answer 3

C++对常量的处理非常严格。如果可能的话（没有UB），复制这样的结构将是痛苦的。也许你真正想要的是“只读”？在这种情况下，您可以使用公共getter/setter将字段设置为私有字段:

struct Foo {
    public:
        Foo(): id(-1), value(-1) {}
        Foo(int id): id(id), value(0) {}

        int getId() const {
            return id;
        }

        int getValue() const {
            return value;
        }

        void setValue(int newValue) {
            value = newValue;
        }

    private:
        int id;
        int value;
};