復制構造函數指針對象

Question

我有下面的類與2個要阻止的指針

#ifndef SCORING_H
#define SCORING_H

#include "Block.h"
#include <iostream>
#include <vector>
#include <cstring>

using namespace std;

class Scoring
{
    public:
        Scoring(Block *, Block*, string, string, double);
        virtual ~Scoring();
        Scoring(const Block& b1, const Block &b2);
    private:
        Block * b1;
        Block * b2;
        string path1;
        string path2;
        double val;
};

#endif // SCORING_H

類塊如下：

class Block {
    public :
        ///constructo
        Block(double, double, double, double, int, vector<LineElement*>);

        ///Setter functions
        void setID(int);
        void setTop(double);
        void setLeft(double);
        void setRight(double);
        void setBottom(double);
        void setLine(vector<LineElement*>);

        int getID();
        double getTop();
        double getLeft();
        double getBottom();
        double getRight();
        vector<LineElement*> getLine();

    private:
        int id;
        vector<LineElement*> Listline;
        double top;
        double left;
        double bottom;
        double right;
};

#endif // ELEMENT_H_INCLUDED

我想知道，是否應該為“ Block * b1; Block * b2”構造一個副本構造函數，以及如何在scoring.h類中處理這兩點？

謝謝。

Answer 1

如果您創建的構造器不是簡單而簡單的Block::Block(const Block&)則它不是復制構造器。 如果要在Scoring中使用兩個Block指針構造一個構造函數，則絕對不是復制構造函數。

如果要在Scoring使用復制構造函數，它應該是這樣的：

class Scoring
{
    // ...

    Scoring(const Scoring& other);

    // ...
};

然后在該構造函數中，從other復制：

Scoring::Scoring(const Scoring& other)
    : b1(new Block(*other.b1)),
      b2(new Block(*other.b2)),
      path1(other.path1),
      path2(other.path2),
      val(other.val)
{
}

當然，您可能也應該為Block類創建一個復制構造函數，因為它包含一個指針向量，否則，您將有兩個指針指向相同對象的向量，當指針指向相同對象時，這將是不好的您可以在一個矢量中刪除這些對象，而在另一矢量中則不刪除。