Unique_Ptr：尝试引用已删除的函数

Question

所以我现在正在用 C++ 做一个学校项目，虽然我对这门语言还不太熟悉。整个项目分为几个里程碑。1：读取具有不同类型生物的列表并将它们存储在向量中 2：读取 TGA 文件并将其存储在类中。... 5：为每个读取的 Creature-Type 读取 TGA-Picture 并将其存储以供进一步使用。（在 GUI 上打印，删除/添加）

所以我认为将每种类型的图片存储在类本身中是个好主意，因为它应该只加载一次。我的 TGAPicture 类中的 load() 函数将返回 std::unique_ptr 所以我在 CreatureType 类中添加了类型作为参数。这样做之后，我得到了几个这样的错误：

Error   C2280   'biosim::CreatureType::CreatureType(const biosim::CreatureType &)': attempting to reference a deleted function  bio-sim-qt  E:\Development\C++\bio-sim-qt\bio-sim-qt\qtmain.cpp 58  1   

Error (active)      function "biosim::CreatureType::CreatureType(const biosim::CreatureType &)" (declared implicitly) cannot be referenced -- it is a deleted function  bio-sim-qt  e:\Development\C++\bio-sim-qt\bio-sim-qt\Model.cpp  15  26  

因此，我阅读了大约 10 个与我的标题类似的问题，并且每个问题都指出，您不能复制 unique_ptr 和建议的解决方案，例如使用 std::move() 或返回引用。尽管我尝试使用这些来解决我的问题，但我一点也做不到，可能是因为我对 C++ 还很陌生，从未使用过唯一指针。

这是代码，似乎与我有关：

/**
 * @class CreatureType
 * Object of the various CreatureTypes ingame
 */
class CreatureType {

    private:
    std::string name;
    int strengh;
    int speed;
    int lifespan;
    std::vector<std::string> attributes;
    std::string path;
    std::unique_ptr<TGAPicture> picture; //What I tried to add in order to stre my pictures

    public:
    CreatureType(const std::string& name
                , int strengh, int speed, int lifespan
                , const std::vector<std::string>& basic_strings
                , const std::string& path);

    /**
    * Initializes list with CreatureTypes by reading from a .txt-File
    */
    static CreatureList load(const std::string& file);

    /**
     * Printing Data in various ways
     */
    void getInfo() const;
    void getInfoInOneLine() const;

    std::string getName() const;
    int getStrengh() const;
    int getSpeed() const;
    int getLifespan() const;
    std::vector<std::string> getAttributes() const;
    std::string getPath() const;
};

}

CreatureType::CreatureType(const std::string& name
                            , int strengh, int speed, int lifespan
                            , const std::vector<std::string>& basic_strings
                            , const std::string& path)
    : name(name),
    strengh(strengh),
    speed(speed),
    lifespan(lifespan),
    attributes(basic_strings),
    path(path),
    picture(TGAPicture::loadPicture(Reference::PicturePath::creatureBasePath + path)){ }

/**
 * Implementation Notes:
 * - Does a line not fullfill the requirenments, it will be ignored
 * - @see <a href="https://elearning.uni-bayreuth.de/pluginfile.php/644828/mod_resource/content/2/Aufgabenblatt_1.pdf">Formation</a>
 * - Prints data with std::cout
 */
CreatureList CreatureType::load(const std::string& file) {
    CreatureList creatureList;
    std::ifstream fileStream; //Datei-Handle
    int lineNumber = 0;
    int correctLinesRead = 0;


    fileStream.open(file, std::ios::in);
    if (!fileStream.is_open()) {
        throw FileNotFoundException(file);
    }

    logger << INFO << "Einlesevorgang wird gestartet\n";

    //One line per loop
    while (!fileStream.eof()) {
        bool skipLine = false;

        std::string line;
        getline(fileStream, line);
        lineNumber++;

        ... //Checking if data is valid 


        //Every Parameter does exist and is valid
        creatureList.push_back(CreatureType(creatureArgs[0]
                                            , strengh, speed, lifespan
                                            , attributes, creatureArgs[5]));
        correctLinesRead++;
    }

return creatureList;
}

TGAP图片：

//no padding bytes
#pragma pack( push, 1 )
/**
 * @struct TGAHeader
 * Represents the standard TGA-Header.
 */
struct TGAHeader {
    char idLength;
    char colourmapType;
    char imagetype;

    short colourmapStart;
    short colourmapLength;
    char colourmapBits;

    short xOrigin;
    short yOrigin;
    short width;
    short height;
    char bits;
    char descriptor;

};
#pragma pack( pop )


/**
* @struct RGBA
* Represents a Pixel with a red, green, blue and possibly alpha value
*/
struct RGBA {
    std::uint8_t B, G, R, A;
};

/**
* @class TGAPicture
* Class used to represent TGA-Files, that are used in the program
*/
class TGAPicture {

    public:
    TGAPicture(const TGAPicture& other)
        : pixel(other.pixel),
        header(other.header),
        width(other.width),
        height(other.height),
        size(other.size),
        bitsPerPixel(other.bitsPerPixel) {}

    TGAPicture(TGAPicture&& other) noexcept
        : pixel(std::move(other.pixel)),
        header(std::move(other.header)),
        width(other.width),
        height(other.height),
        size(other.size),
        bitsPerPixel(other.bitsPerPixel) {}

    TGAPicture& operator=(const TGAPicture& other) {
        if (this == &other)
            return *this;
        pixel = other.pixel;
        header = other.header;
        width = other.width;
        height = other.height;
        size = other.size;
        bitsPerPixel = other.bitsPerPixel;
        return *this;
    }

    TGAPicture& operator=(TGAPicture&& other) noexcept {
        if (this == &other)
            return *this;
        pixel = std::move(other.pixel);
        header = std::move(other.header);
        width = other.width;
        height = other.height;
        size = other.size;
        bitsPerPixel = other.bitsPerPixel;
        return *this;
    }

    private:
    std::vector<RGBA> pixel; //Containes every pixel of the picture
    TGAHeader header;
    short width, height, size, bitsPerPixel;

    ...

    public:
    /**
    * Loads and initializes a picture to be used in the program
    * @throws TGAExpection if file could not be loaded
    */
    static std::unique_ptr<TGAPicture> loadPicture(const std::string& path);
    TGAPicture(const std::vector<RGBA>& pixel, const TGAHeader& header);
    ~TGAPicture();
    ....
};
}
#endif

cp：

TGAPicture::TGAPicture(const std::vector<RGBA>& pixel, const TGAHeader& header)
    : pixel(pixel),
    header(header),
    width(header.width),
    height(header.height),
    size(header.width * header.height * (header.bits / 8)),
    bitsPerPixel(header.bits) { }



std::unique_ptr<TGAPicture> TGAPicture::loadPicture(const std::string& path) {
    ...


    for (int i = 0; i < header.height * header.width; i++) {
        pixel[i].B = *(bufferPosition++);
        pixel[i].G = *(bufferPosition++);
        pixel[i].R = *(bufferPosition++);
        pixel[i].A = (header.bits > 24 ? *(bufferPosition++) : 0xFF);
    }

    /**
     * Return unique_ptr
     * - ObjectFactory
     * - Automatic Deletion
     */
    return std::unique_ptr<TGAPicture>{new TGAPicture(pixel, header)};

}

一个有错误的类是：

class Model {

    public:
    explicit Model(const CreatureList& creatureList);
    ~Model();


    Terrain* getTerrain() const;
    CreatureList& getCreatureList();

    private:
    CreatureList creatureList;
    Terrain* terrain;

};


Model::Model(const CreatureList& creatureList) : creatureList(creatureList),
                                                terrain(new Terrain()) {

    for (CreatureType ty : creatureList) {  //line with errror
        ty.getInfoInOneLine();
    }
}

我需要改变什么才能让它工作？什么是最佳方式？很确定我应该使用 unique_ptr 作为 TGA::load() 方法的返回值。我希望你能看穿这个烂摊子，如果我的英语不完美，我想道歉，因为这不是我的第一门语言。

Answer 1

std::unique_ptr不可复制。如果你能复制它，它就不再是独一无二的了。

您在in的构造函数的循环中创建元素的副本，但它们具有不可复制的成员，因此默认情况下它们本身是不可复制的。如果您实际上不需要元素的副本，则应使用引用：creatureListModel

Model::Model(const CreatureList& creatureList)
    : creatureList(creatureList),
      terrain(new Terrain())
{
    for (CreatureType& ty : creatureList) {  // changed to reference instead
                                             // Note: this is still working with
                                             //       parameter, not the object's
                                             //       member.
        ty.getInfoInOneLine();
    }
}

您实际上并未提供 的定义CreatureList，但我怀疑它也不可复制。这意味着Model::Model不能将 的参数复制到对象的成员中。您有两个选择来解决这个问题：确保移动您的CreatureList或使其可复制。

std::unique_ptr是可移动的，这意味着CreatureType默认情况下也是如此，因此您可以执行以下操作：

Model::Model(CreatureList creatureList)  // Take by value now
    : creatureList(std::move(creatureList)),  // Move the parameter to the member
      terrain(new Terrain())
{
    for (CreatureType& ty : this->creatureList) {  // Use this-> to access member
                                                   // instead of now moved-from
                                                   // parameter.  You could also
                                                   // just change them to have
                                                   // different names.
        ty.getInfoInOneLine();
    }
}

这会更改Model的构造函数以按值获取其参数并将该值移动到对象的creatureList成员中。

如果有意义，您还可以CreatureType通过添加显式复制构造函数来复制指向的对象picture：

CreatureType::CreatureType(const CreatureType& other)
    : name(other.name),
      strengh(other.strengh),
      speed(other.speed),
      lifespan(other.lifespan),
      attributes(other.attributes),
      path(other.path),
      picture(new TGAPicture(*other.picture))
{
}

如果这样做，编译器将不再生成隐式移动构造函数，因此您需要自己定义它：

CreatureType::CreatureType(CreatureType&& other)
    : name(std::move(other.name)),
      strengh(other.strengh),
      speed(other.speed),
      lifespan(other.lifespan),
      attributes(std::move(other.attributes)),
      path(std::move(other.path)),
      picture(std::move(other.picture))
{
}

似乎没有任何理由TGAPicture::loadPicture返回 a std::unique_ptr。如果您只是从该函数中按值返回，您将避免所有这些问题：

TGAPicture TGAPicture::loadPicture(const std::string& path) {
    // ...
    return TGAPicture{pixel, header};
}