C++ 如何求向量中所有元素的和？

我想输入形状的数量和形状面积的总和

输入的第一行是要计算的形状数量，在第一行之后，可以输入形状的类型和大小

但我在计算三角形和矩形的面积时遇到了一个问题，除了圆。只有圆的面积计算得很好

$ ./a.out
1
R 2.0 1.0
0.00

$ ./a.out
1
T 2.0
0.00

$ ./a.out
1
C 1.0
3.14

我认为问题来自

 for (int i = 0; i < n ; i++)
    {
        sum += collection[i]->area(collection);
    }

for（int i=0；i面积（集合）；
}

这个密码！我想我的面积函数只计算向量的第一个元素

#include <iostream>
#include <iomanip>
#include <cmath>
#include <vector>
#include <algorithm>

using namespace std;

class Shape{
protected:
    int _r;
    int _w;
    int _h;

public:
    Shape(double r) : _r(r) {}
    Shape(double w, double h) : _w(w), _h(h) {}
    virtual double area(vector<Shape *>) = 0;
};

class Circle : public Shape{
public:
    Circle(double r) : Shape(r) {}
    double area(vector<Shape *>) { return _r*_r*atan(1)*4.0; }
};

class Triangle : public Shape{
public:
    Triangle(double s) : Shape(s) {}
    double area(vector<Shape *>) { return sqrt(3) * pow(_r, 2) / 4; }
};

class Rectangle : public Shape{
public:
    Rectangle(double w, double h) :Shape(w, h) {}
    double area(vector<Shape *>) { return  _w * _h ;}
};

int main()
{

    int n;
    char info;
    int value;
    int value2;
    double sum;
    vector<Shape*> collection;
    vector<int> answer;

    sum = 0;

    cin >> n;

    for(int i = 0 ; i < n + 1; i++)
    {
        cin >> info;
        if (info == 'C')
        {
            cin >> value;
            Circle c(value);
            collection.push_back(&c);
        }
        else if (info == 'R')
        {
            cin >> value;
            cin >> value2;
            Rectangle r(value, value2);
            collection.push_back(&r);
        }
        else
        {
            cin >> value;
            Triangle t(value);
            collection.push_back(&t);
        }
    }
    for (int i = 0; i < n + 1 ; i++)
    {
        sum += collection[i] -> area(collection);
    }
    cout << fixed << setprecision(2) << sum << endl;
}

#包括
#包括
#包括
#包括
#包括
使用名称空间std；
阶级形态{
受保护的：
国际(r)；
国际(w)；
int_h；
公众：
形状（双r）：\uR（r）{}
形状（双w，双h）：w（w），h（h）{}
虚拟双面积（矢量）=0；
};
班级圈子：公共形态{
公众：
圆（双r）：形状（r）{}
双面积（向量）{return\ur*\ur*atan（1）*4.0；}
};
类三角形：公共形状{
公众：
三角形（双s）：形状（s）{}
双面积（向量）{return sqrt（3）*pow（_r，2）/4；}
};
类矩形：公共形状{
公众：
矩形（双w，双h）：形状（w，h）{}
双面积（向量）{return{uw*h；}
};
int main（）
{
int n；
字符信息；
int值；
int值2；
双和；
媒介收集；
向量答案；
总和=0；
cin>>n；
对于（int i=0；i>信息；
如果（信息=='C'）
{
cin>>值；
圈c（数值）；
收集。推回（&c）；
}
否则如果（信息='R'）
{
cin>>值；
cin>>值2；
矩形r（值，值2）；
收集。推回（&r）；
}
其他的
{
cin>>值；
三角形t（值）；
收集。推回（&t）；
}
}
对于（int i=0；i面积（集合）；
}
cout有许多有趣的错误：

我不知道为什么要将
向量
传递给
区域（）
方法
我不明白您为什么从
0..n+1
进行迭代。它与您提供的输入不匹配
如注释中所述，您将继续引用指向超出范围的对象的指针。使用堆是解决此问题的简单方法。使用
unique\u ptr
还可以确保内存将被清理
由于您使用的是继承，因此最好让基类具有虚拟析构函数
#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
阶级形态{
受保护的：
国际(r)；
国际(w)；
int_h；
公众：
形状（双r）：\uR（r）{}
形状（双w，双h）：w（w），h（h）{}
virtual~Shape（）=默认值；
虚拟双区（）=0；
};
班级圈子：公共形态{
公众：
圆（双r）：形状（r）{}
双区（）{return\ur*\ur*atan（1）*4.0；}
};
类三角形：公共形状{
公众：
三角形（双s）：形状（s）{}
双区（）{return sqrt（3）*pow（_r，2）/4；}
};
类矩形：公共形状{
公众：
矩形（双w，双h）：形状（w，h）{}
双区域（）{return\u w*\u h；}
};
int main（）{
int n；
字符信息；
int值；
int值2；
双和=0
媒介收集；
cin>>n；
对于（int i=0；i>信息；
如果（信息=='C'）
{
cin>>值；
collection.push_back（std:：make_unique（value））；
}
否则如果（信息='R'）
{
cin>>值；
cin>>值2；
collection.push_back（std:：make_unique（value，value2））；
}
其他的
{
cin>>值；
collection.push_back（std:：make_unique（value））；
}
}
对于（int i=0；iarea（）；
}
cout您的代码。您不能推回
区域
，因为它不是
形状*
的函数。请尝试推回
形状
的副本，而不是指针。因为在
推回
之后，您的所有输入都超出范围。您创建形状，将其地址推到向量中，当您到达范围的末尾时，您的对象将被销毁oyed，但地址在向量中保持不变，指向垃圾。这被称为悬挂指针。@LouisGo:
Shape
是纯虚拟的，因此
std:：vector
无效。已经有用于此目的的地址1.我不知道为什么要将向量传递到区域（）因为我想做一个参数是向量的方法，它计算所有的和的面积。2，我不明白为什么你要从0…n + 1迭代。它与你所提供的输入不匹配。->我想是这样。但是，在我的第一行输入中，需要N+1。例如，如果我在第一行输入2，我的程序只考虑一个形状，而不是TW。o形状3的数量。如注释中所述，您正在继续引用指向超出范围的对象的指针。使用堆是解决此问题的简单方法。使用唯一的\u ptr也可以确保内存将被清理。->我想使用，但我的编译器显示错误。您的编译器在这方面做得好吗？？
#include <iostream>
#include <iomanip>
#include <cmath>
#include <vector>
#include <algorithm>
#include <memory>

using namespace std;

class Shape{
  protected:
    int _r;
    int _w;
    int _h;

  public:
    Shape(double r) : _r(r) {}
    Shape(double w, double h) : _w(w), _h(h) {}
    virtual ~Shape() = default;
    virtual double area() = 0;
};

class Circle : public Shape{
  public:
    Circle(double r) : Shape(r) {}
    double area() { return _r*_r*atan(1)*4.0; }
};

class Triangle : public Shape{
  public:
    Triangle(double s) : Shape(s) {}
    double area() { return sqrt(3) * pow(_r, 2) / 4; }
};

class Rectangle : public Shape{
  public:
    Rectangle(double w, double h) :Shape(w, h) {}
    double area() { return  _w * _h ;}
};

int main() {
    int n;
    char info;
    int value;
    int value2;
    double sum = 0
    vector<std::unique_ptr<Shape>> collection;

    cin >> n;

    for(int i = 0 ; i < n; i++)
    {
        cin >> info;
        if (info == 'C')
        {
            cin >> value;
            collection.push_back(std::make_unique<Circle>(value));
        }
        else if (info == 'R')
        {
            cin >> value;
            cin >> value2;
            collection.push_back(std::make_unique<Rectangle>(value, value2));
        }
        else
        {
            cin >> value;
            collection.push_back(std::make_unique<Triangle>(value));
        }
    }
    for (int i = 0; i < n; i++)
    {
        sum += collection[i]->area();
    }
    cout << fixed << setprecision(2) << sum << endl;
}