编写此代码的更有效方法是什么？ P>我是C++的新手，我想学习继承。我写了一个程序，只需打印出不同形状的周长，即正方形和三角形。不幸的是，我这样做的结果是一些重复的代码。我的意思是： #include <iostream> class Shape { public: int sides; int sideLength; }; class Square : public Shape { public: int sides = 4; int sideLength = 6; void calculatePerimeter() { int perimeter = sideLength * sides; std::cout << "perimeter length: " << perimeter << std::endl; } }; class Triangle : public Shape { public: int sides = 3; int sideLength = 4; void calculatePerimeter() { int perimeter = sideLength * sides; std::cout << "perimeter length: " << perimeter << std::endl; } }; int main() { Square s; std::cout << "number of sides a square has: " << s.sides << std::endl; Triangle t; std::cout << "number of sides a triangle has: " << t.sides << std::endl; s.calculatePerimeter(); t.calculatePerimeter(); }

如您所见，calculatePerimeter函数正在正方形和三角形类中使用。将其放入Shape类中并调用它会导致输出为0。如何提高效率，使我不必为我创建的每个形状类复制/粘贴它？

此代码：

内边=3； 内边长=4

正在使用局部范围视图创建新变量。在不运行代码的情况下，我可以想象，如果您简单地去掉两行前面的“int”，应该可以解决您的问题

编辑：当然，将它们放入构造函数中

编辑：好的，合并代码

    class Triangle : public Shape {
public:

  Triangle ()
  {
    sides = 3;
    sideLength = 4;
  }

  void calculatePerimeter() {
    int perimeter = sideLength * sides;
    std::cout << "perimeter length: " << perimeter << std::endl;
  }
};

根据您试图理解的内容，其他答案是更好的问题解决方案。这很简单，只需将参数放入CalculatePerimeter方法，但这当然不会测试您对某个范围内变量的理解，这似乎是您的绊脚石。

此代码：

内边=3； 内边长=4

正在使用局部范围视图创建新变量。在不运行代码的情况下，我可以想象，如果您简单地去掉两行前面的“int”，应该可以解决您的问题

编辑：当然，将它们放入构造函数中

编辑：好的，合并代码

    class Triangle : public Shape {
public:

  Triangle ()
  {
    sides = 3;
    sideLength = 4;
  }

  void calculatePerimeter() {
    int perimeter = sideLength * sides;
    std::cout << "perimeter length: " << perimeter << std::endl;
  }
};

---

根据您试图理解的内容，其他答案是更好的问题解决方案。这很简单，只需将参数放入CalculatePerimeter方法，但这当然不会测试您对某个范围内变量的理解，这似乎是您的绊脚石。

当您使用继承时，您可以在基类中考虑常见行为和状态，并使派生类使用其特定功能扩展此状态和行为

从形状上拆下侧面和边长构件。相反，在类形状中提供返回这些值的虚拟函数，并让派生类重写它们

Move方法计算类形状的周长，并使用getSides和getSideLength实现它

#include <iostream>

class Shape {
public:
  virtual int getSides() = 0;
  virtual int getSideLength() = 0;
  void calculatePerimeter() {
    int perimeter = getSideLength() * getSides();
    std::cout << "perimeter length: " << perimeter << std::endl;
  }
};

class Square : public Shape {
public:
  virtual int getSides() {
    return 4;
  }

  virtual int getSideLength() {
    return 6;
  }
};

class Triangle : public Shape {
public:
  virtual int getSides() {
    return 3;
  }

  virtual int getSideLength() {
    return 4;
  }
};

---

这就是所谓的模板方法设计模式，它不与C++的模板函数概念混淆，它是与此语言相关的完全无关的概念。您可以在基类中考虑常见行为和状态，并使派生类使用其特定功能扩展此状态和行为

从形状上拆下侧面和边长构件。相反，在类形状中提供返回这些值的虚拟函数，并让派生类重写它们

Move方法计算类形状的周长，并使用getSides和getSideLength实现它

#include <iostream>

class Shape {
public:
  virtual int getSides() = 0;
  virtual int getSideLength() = 0;
  void calculatePerimeter() {
    int perimeter = getSideLength() * getSides();
    std::cout << "perimeter length: " << perimeter << std::endl;
  }
};

class Square : public Shape {
public:
  virtual int getSides() {
    return 4;
  }

  virtual int getSideLength() {
    return 6;
  }
};

class Triangle : public Shape {
public:
  virtual int getSides() {
    return 3;
  }

  virtual int getSideLength() {
    return 4;
  }
};

---

这就是所谓的模板方法设计模式，它不与C++的模板函数概念混淆，它是与此语言无关的概念。

可以直接访问基类成员，也可以初始化它们。

class Shape {
public:
  int sides;
  int sideLength;
  Shape(int m,int n)
  {
      sides =m;
     sideLength = n;
  }
};

class Square : public Shape {
public:
  Square(int j,int k);

  int calculatePerimeter() {
    int perimeter = sides * sideLength ;
    std::cout << "perimeter length: " << perimeter << std::endl;
    return perimeter;
  }
};

Square::Square(int j,int k):Shape(j,k)
{


}

---

您可以访问直接的基类成员并初始化它们

class Shape {
public:
  int sides;
  int sideLength;
  Shape(int m,int n)
  {
      sides =m;
     sideLength = n;
  }
};

class Square : public Shape {
public:
  Square(int j,int k);

  int calculatePerimeter() {
    int perimeter = sides * sideLength ;
    std::cout << "perimeter length: " << perimeter << std::endl;
    return perimeter;
  }
};

Square::Square(int j,int k):Shape(j,k)
{


}

---

您需要一个用于Shape和传递派生构造函数中的变量的构造函数。然后可以将calculatePerimiter移动到父类中

class Shape {
public:
  Shape(int n_sides, int side_length) : sides(n_sides), sideLength(side_length) {}

  void calculatePerimeter() {
    int perimeter = sideLength * sides;
    std::cout << "perimeter length: " << perimeter << std::endl;
  }

  int sides;
  int sideLength;
};

class Square : public Shape {
public:
  Square() : Shape(4,6) {}     
};

class Triangle : public Shape {
public:
  Triangle() : Shape(3, 4) {}
};

---

您需要一个用于Shape和传递派生构造函数中的变量的构造函数。然后可以将calculatePerimiter移动到父类中

class Shape {
public:
  Shape(int n_sides, int side_length) : sides(n_sides), sideLength(side_length) {}

  void calculatePerimeter() {
    int perimeter = sideLength * sides;
    std::cout << "perimeter length: " << perimeter << std::endl;
  }

  int sides;
  int sideLength;
};

class Square : public Shape {
public:
  Square() : Shape(4,6) {}     
};

class Triangle : public Shape {
public:
  Triangle() : Shape(3, 4) {}
};

---

这应该能回答你的问题。另外，我建议将sides和sideLength的值作为参数传递给函数调用，以实现一般用法

#include <iostream>

class Shape {
    protected void calculatePerimeter(int sides, int sideLength) {
    int perimeter = sideLength * sides;
    std::cout << "perimeter length: " << perimeter << std::endl;
  }
};

class Square : public Shape {
  int sides = 4;
  int sideLength = 6;
  public void calculatePerimeter()
  {
      Shape::calculatePerimeter(sides, sideLength);
  }
};

class Triangle : public Shape {
  int sides = 3;
  int sideLength = 4;
  public void calculatePerimeter()
  {
      Shape::calculatePerimeter(sides, sideLength);
  }
};

int main() {
  Square s;
  std::cout << "number of sides a square has: " << s.sides << std::endl;

  Triangle t;
  std::cout << "number of sides a triangle has: " << t.sides << std::endl;

  s.calculatePerimeter();
  t.calculatePerimeter();
}

---

这应该能回答你的问题。另外，我建议将sides和sideLength的值作为参数传递给函数调用，以实现一般用法

#include <iostream>

class Shape {
    protected void calculatePerimeter(int sides, int sideLength) {
    int perimeter = sideLength * sides;
    std::cout << "perimeter length: " << perimeter << std::endl;
  }
};

class Square : public Shape {
  int sides = 4;
  int sideLength = 6;
  public void calculatePerimeter()
  {
      Shape::calculatePerimeter(sides, sideLength);
  }
};

class Triangle : public Shape {
  int sides = 3;
  int sideLength = 4;
  public void calculatePerimeter()
  {
      Shape::calculatePerimeter(sides, sideLength);
  }
};

int main() {
  Square s;
  std::cout << "number of sides a square has: " << s.sides << std::endl;

  Triangle t;
  std::cout << "number of sides a triangle has: " << t.sides << std::endl;

  s.calculatePerimeter();
  t.calculatePerimeter();
}

---

这将是我的方法为编译器，支持C++11

#include <iostream>
#include <string>
#include <vector>

using namespace std;

template<class Seq>
void purge(Seq& s) {
    for (auto x: s) {
        delete x;
        x = nullptr;
    }
}

class Shape {
public: 
    virtual void calculatePerimeter() = 0; // to avoid object slicing
    virtual ~Shape() {};
};

class Square : public Shape {
    int m_sides{0};
    int m_sideLength{0};
public: 
    Square() = delete; // suppress default constructor
    Square(int sides, int sideLength): m_sides(sides), m_sideLength(sideLength) {}
    ~Square() {}
    void calculatePerimeter() {
        int perimeter = m_sideLength * m_sides;
        cout << "Square perimeter length: " << perimeter << endl;
    }
};

class Triangle : public Shape {
    int m_sides{0};
    int m_sideLength{0};
public: 
    Triangle() = delete; // suppress default constructor
    Triangle(int sides, int sideLength): m_sides(sides), m_sideLength(sideLength) {}
    ~Triangle() {}
    void calculatePerimeter() {
        int perimeter = m_sideLength * m_sides;
        cout << "Triangle perimeter length: " << perimeter << endl;
    }
};

int main() {
    vector<Shape*> vec;

    vec.push_back(new Square(4, 7));
    vec.push_back(new Triangle(3, 13));

    for (auto x: vec) {
        x->calculatePerimeter();
    }

    // clean up
    purge(vec);

    system("pause");
    return 0;
}

---

这将是我的方法为编译器，支持C++11

#include <iostream>
#include <string>
#include <vector>

using namespace std;

template<class Seq>
void purge(Seq& s) {
    for (auto x: s) {
        delete x;
        x = nullptr;
    }
}

class Shape {
public: 
    virtual void calculatePerimeter() = 0; // to avoid object slicing
    virtual ~Shape() {};
};

class Square : public Shape {
    int m_sides{0};
    int m_sideLength{0};
public: 
    Square() = delete; // suppress default constructor
    Square(int sides, int sideLength): m_sides(sides), m_sideLength(sideLength) {}
    ~Square() {}
    void calculatePerimeter() {
        int perimeter = m_sideLength * m_sides;
        cout << "Square perimeter length: " << perimeter << endl;
    }
};

class Triangle : public Shape {
    int m_sides{0};
    int m_sideLength{0};
public: 
    Triangle() = delete; // suppress default constructor
    Triangle(int sides, int sideLength): m_sides(sides), m_sideLength(sideLength) {}
    ~Triangle() {}
    void calculatePerimeter() {
        int perimeter = m_sideLength * m_sides;
        cout << "Triangle perimeter length: " << perimeter << endl;
    }
};

int main() {
    vector<Shape*> vec;

    vec.push_back(new Square(4, 7));
    vec.push_back(new Triangle(3, 13));

    for (auto x: vec) {
        x->calculatePerimeter();
    }

    // clean up
    purge(vec);

    system("pause");
    return 0;
}

模板方式：

template <std::size_t SideCount, typename T>
class EquilateralPolygon
{
public:
    explicit EquilateralPolygon(T sideLength) : sideLength(sideLength) {}
    std::size_t GetSideCount() const { return SideCount; }
    T GetSideLength() const { return sideLength; }

    T calculatePerimeter() const { return SideCount * sideLength; }
private:
    T sideLength;
};

template <std::size_t SideCount, typename T>
void displayPerimeter(const EquilateralPolygon<SideCount, T>& p) {
    std::cout << "perimeter length: " << p.calculatePerimeter() << std::endl;
}

using EquilateralTriangle = EquilateralPolygon<3, std::size_t>;
using Square = EquilateralPolygon<4, std::size_t>;

使用方法：

int main() {
    Square s(5);
    std::cout << "number of sides a square has: " << s.GetSideCount() << std::endl;

    EquilateralTrianglet(5);
    std::cout << "number of sides a triangle has: " << t.GetSideCount() << std::endl;

    displayPerimeter(s);
    displayPerimeter(t);
}

模板方式：

template <std::size_t SideCount, typename T>
class EquilateralPolygon
{
public:
    explicit EquilateralPolygon(T sideLength) : sideLength(sideLength) {}
    std::size_t GetSideCount() const { return SideCount; }
    T GetSideLength() const { return sideLength; }

    T calculatePerimeter() const { return SideCount * sideLength; }
private:
    T sideLength;
};

template <std::size_t SideCount, typename T>
void displayPerimeter(const EquilateralPolygon<SideCount, T>& p) {
    std::cout << "perimeter length: " << p.calculatePerimeter() << std::endl;
}

using EquilateralTriangle = EquilateralPolygon<3, std::size_t>;
using Square = EquilateralPolygon<4, std::size_t>;

使用方法：

int main() {
    Square s(5);
    std::cout << "number of sides a square has: " << s.GetSideCount() << std::endl;

    EquilateralTrianglet(5);
    std::cout << "number of sides a triangle has: " << t.GetSideCount() << std::endl;

    displayPerimeter(s);
    displayPerimeter(t);
}

---

如果删除int，则会发生编译时错误。这是如何解决上述问题的？为每个被重写的类编写一个构造函数，并将变量移到其中。类三角形：public Shape{public:Triangle{sides=3；sideLength=4；}；void calculatePerimeter{int permiture=sideLength*sides；std:：cout您应该将其与您的答案结合起来，使其成为一个完整的答案。如果删除int，则会发生编译时错误。这如何解决上述问题？为每个重写的类编写构造函数，并将变量移到其中。类三角形：公共形状{public:Triangle{sides=3；sideLength=4；}；void calculatePerimeter{int perime=si

---

删除*边的长度；std：：你能不能把这个和你的答案结合起来，使它成为一个完整的答案。但是正方形总是有4条边，所以它不应该是一个从外部给定的变量。但是正方形总是有4条边，所以它不应该是一个从外部给定的变量。所以我们可以创建42条边的正方形或三角形：-所以我们可以创建42条边的正方形或三角形：-注意该Square实际上有4个成员：Shape:：sides，Shape:：sideLength，Square:：sideLength…@Jarod42确实如此，我来自Java，在扩展类中声明一个变量会覆盖该变量，而不是复制它…看起来我有很多东西要学。注意Square实际上有4个成员：Shape:：sides，Shape:：sideLength，Square:：sideLength，Square:：sideLength…@Jarod42确实如此，我来自Java，在扩展类中声明变量会覆盖变量，而不是复制变量…看起来我有很多东西要学。没有解释的代码不是一个好答案，特别是如果代码没有回答问题的话。他问了一些减少复制/粘贴代码的方法，但如果有一个非常简单的方法，你的答案仍然需要。@JohnDrouhard这是解决问题的另一种方法，是的，我的代码重复了函数定义，但至少没有重复其中的内容。此外，我想在这里指出调用基类方法的另一种方法。正如你所看到的，用户是一个“新手”，我不明白你怎么能在没有适当解释的情况下抛出包含“虚拟”和“模板”的答案，并期望用户理解？你说了一个简单的解决方案。我相信我的代码是上面所有方法中最简单的。请告诉我你认为哪种解决方案对“新手”来说是最简单的。没有解释的代码不是一个好答案，特别是如果代码没有回答问题。他问了一些减少复制/粘贴代码的方法，但如果有一个非常简单的方法，你的答案仍然需要。@JohnDrouhard这是解决问题的另一种方法，是的，我的代码重复了函数定义，但至少没有重复其中的内容。此外，我想在这里指出调用基类方法的另一种方法。正如你所看到的，用户是一个“新手”，我不明白你怎么能在没有适当解释的情况下抛出包含“虚拟”和“模板”的答案，并期望用户理解？你说了一个简单的解决方案。我相信我的代码是上面所有方法中最简单的。请告诉我，根据您的说法，对于“新手”来说，哪种解决方案最简单。非常感谢您，它非常有效，而且远没有那么难看。谢谢你也解释了答案，我很感激。非常感谢你，它很好用，而且不那么难看。谢谢你也解释了答案，我很感激。