Question

我有以下类，其中有两个指向阻塞的指针

#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如下：

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类创建一个复制构造函数，因为它包含一个指针向量，如果不包含，您将有两个向量，指针指向同一个对象，当你在一个向量中删除这些对象而在另一个向量中删除这些对象时，这将是不好的。

复制构造函数指针对象

1 个答案: