Unique_Ptr: 正在尝试引用已删除的函数

Unique_Ptr: Attemting To Reference A Deleted Function

所以我现在正在用 C++ 做一个学校项目,尽管我还不太熟悉这种语言。 整个项目分为几个里程碑。 1:读取包含不同类型生物的列表并将它们存储在向量中 2:读取一个TGA-File,存入一个class。 ... 5: 每次读取 Creature-Type 读取一个 TGA-Picture 并将其存储以备后用。 (在 GUI 上打印,Remove/add)

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

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() 或 returning一个参考。 虽然我尝试使用这些来解决我的问题,但我一点也做不到,可能是因为我是 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;
}

TGA图片:

//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

cpp:

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 有错误的是:

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 作为 return 用于 TGA::load() 方法。 我希望你能看穿这个烂摊子,如果我的英语不完美,我想道歉,因为这不是我的第一语言。

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

您在 Model 的构造函数中的循环中创建了 creatureList 中元素的 副本 ,但它们有一个不可复制的成员,并且所以默认情况下它们本身是不可复制的。如果您实际上不需要元素的副本,则应使用引用:

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 到 return 和 std::unique_ptr 似乎没有任何理由。如果您只是 return 该函数的值,您将避免所有这些问题:

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