使用const值将结构复制到数组

如何解决使用const值将结构复制到数组

我正在尝试替换非const数组中具有const值的struct值，但编译失败：

Object of type 'Foo' cannot be assigned because its copy assignment operator is implicitly deleted

这里是一个例子：

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;
}

我来自迅速的背景，那是有效的，因为它将结构值复制到数组中。

我尝试使我认为是副本分配运算符，但对于const成员，我尝试的操作也不起作用。

这是我要为副本分配运算符执行的操作：

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

对数组执行memcpy可以正常工作，但看起来像是用错的大锤。

在c ++上成为新手，我不确定这种流的正确模式是什么。

解决方法

C ++非常严格地对待const。如果可能的话，复制这样的结构会很痛苦（没有UB）。也许您真正要寻找的是“只读”呢？在这种情况下，您可以将字段与公共获取者/设置者私有化：

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;
};

,

POST初始化后就永远不能更改。

从名称const开始，听起来您就需要 move 语义。可以使两个对象之间的数据移动，而不是复制。

，而不是使两个有效的对象具有相同的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';
}

,

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

foos[0] = Foo(1234);

这确实失败了。您可以做的一件事是拥有一个不是Foos的容器，而是一个指向foo的指针。因此，您将为指针分配内存，但仅在可能的情况下才创建实际对象。例如：

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

您可以考虑在此处使用std::unique_ptr之类的智能指针，而不是原始指针。