0

我有以下带有 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”构造一个复制构造函数，以及如何在 score.h 类中处理这两个点？

谢谢你。

4

1 回答 1

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

于 2013-05-30T13:07:56.870 回答