编写此代码的更有效方法是什么？

Question

So, I'm a newbie in C++ and I'm trying to learn about inheritance. I wrote out a program that just simply prints out the perimeter of different shapes, namely a square and a triangle. Unfortunately, the way I'm doing it ends up with some duplicated code. Here's what I mean:

#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();
}

As you can see, the calculatePerimeter function is being used in the Square and the Triangle classes. Putting it in the Shape class and calling it resulted in an output of 0. How can I make this more efficient so I don't have to copy/paste it for every shape class I make?

Answer 1

When you use inheritance, you factor common behavior and state in the base class and make derived classes extend this state and behavior with their specific functionality.

1. Remove the sides and sideLength members from Shape. Instead, provide virtual functions in class Shape that return those values, and have the derived classes override them.

2. Move method calculate perimeter to class Shape, and implement it using the getSides() and 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; } }; 

This is what is known as a Template Method design pattern (not to be confused with the template function concept of C++, which is an entirely unrelated concept specific to this language).

Answer 2

You need a constructor for Shape and to pass the variables through from the derived constructors. Then you can move calculatePerimiter into the parent class.

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) {}
};

Answer 3

This code:

int sides = 3; int sideLength = 4;

is creating new variables with a local scope view. Without running your code, I would imagine if you simply got rid of the 'int' in front of both lines should fix your problem.

Edit: put them into a constructor of course.

Edit: Ok, combining code...

    class Triangle : public Shape {
public:

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

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

Depending what it is you are trying to understand, the other answers are better solutions to the problem. This is simple enough to just put parameters into the calcualatePerimeter() method, but that of course does not test your understanding of variables within a scope, which seemed to be your stumbling block.

Answer 4

You can acess immediate base class members and also initialise them.

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)
{


}

Answer 5

This would be my approach for a compiler that supports 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;
}

Answer 6

The template way:

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

And usage:

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);
}

Live Demo

Answer 7

This should answer your question. Also, I would recommend passing the values of sides and sideLength as parameters to the function calls to enable generic usage.

#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();
}