C+中的函数继承和返回类型+； 我学习C++，我遇到了一个问题，我可以用我以前的编程经验来解决（主要是C和java；一些但OOP经验有限），但是我想知道什么是一个合适的，现代C++解决方案。该问题涉及具有不同返回类型的虚拟函数的继承和派生类版本。基于多个堆栈溢出线程，这样的事情是不可能的。那么，我应该如何进行以下工作 < >练习C++的特性，我正在编写一个光线跟踪程序。我有一个虚拟基类对象和派生类多面体和多边形来描述光线可以与之交互的对象。（事实上，我有中间的虚拟类实体和面，和派生类球体，圆柱体，圆形，旁边是多面体和多边形，但为了简单起见，我们先把它们忘了。），我只实现了光的发射和吸收，也就是说，光线只能直射，没有任何折射或反射。多面体内的吸收与强度成正比（指数衰减），因此我必须计算出射线穿过的物体，并将射线的强度从其源向前积分到它击中探测器的位置。我有一个向量std:：vector crossions来存储射线与模拟场景中的对象的所有这些交点。对于多面体对象，交点需要包含交点点s、相交的多边形面和多面体本身，或者对于多边形对象，交点点和多边形面本身。因此，我希望使用派生类Intersection\u Polyhedron和Intersection\u Polygon来覆盖对Intersection:：modulate\u intensity（const double intensity\u before）const的调用，该调用应该在经过相关对象后返回光线的强度。换句话说，我希望避免检查相交对象的类型，而是在计算光线强度的调制时利用继承

我想让每个

Ray

简单地循环通过一个向量

std:：vector objects

来包含模拟场景中的所有对象，调用虚拟函数

Object:：get_intersection（const-Ray&Ray）const

并根据交点的类型（如果与

多面体

或

多边形

相交）获取

相交(多面体

或

多边形

)。指向这些派生交叉点对象的指针将被推回

交叉点

，

交叉点

将根据与

光线

原点的距离进行排序，然后循环调用并覆盖

交叉点：：调制强度（）

确定探测器上光线的最终强度。对我来说，这听起来像是C++/OOP实现这一点的方式，但这似乎不可能，因为基类虚函数的派生类版本都必须具有相同的返回类型。那我该怎么做呢

（目前，我从

get_Intersection（）

为

多面体和
多边形返回一个单一类型的
交集
。作为其成员，
交集
具有交集
点的向量
和相交的
std:：shared_ptr
面和
std:：shared_ptr
（这是一个
nullptr
，用于
Polygon
s，因为没有块体）为了区分<代码>多面体< /代码>和<代码>多边形< /代码>，我简单地检查是否存在一个或两个交集<代码>点>代码>这不是太不雅，但是现代C++必须提供一个更好的继承方式来实现这一点，对吗？
一些非常喜欢C++的伪代码进一步阐明了我想要实现的目标：

// ...

// create objects in a scene
std::vector<std::shared_ptr<Object>> objects;
// ...

// find a ray's intersections with the objects
std::vector<std::shared_ptr<Intersection>> intersections;
for(const auto& object : objects) {
  // virtual class Object's function overridden with that of Polyhedron or Polygon
  // returns std::shared_ptr<Intersection_Polyhedron> or std::shared_ptr<Intersection_Polygon> based on type of object
  auto intersection = object->get_intersection(ray);
  intersections.push_back(intersection);
}

// sort the intersections with std::sort and a lambda expression
// ...

// calculate a ray's intensity
double intensity = 0.0;
for(const auto& intersection : intersections) {
  // virtual class Intersection's function overridden with that of Intensity_Polyhedron or Intensity_Polygon
  intensity = intersection->modulate_intensity(intensity);
}

// ...

/。。。
//在场景中创建对象
向量对象；
// ...
//查找光线与对象的交点
向量交点；
用于（常量自动和对象：对象）{
//虚拟类对象的函数被多面体或多边形的函数覆盖
//根据对象类型返回std:：shared_ptr或std:：shared_ptr
自动相交=对象->获取相交（光线）；
交叉口。向后推（交叉口）；
}
//使用std:：sort和lambda表达式对交点进行排序
// ...
//计算光线的强度
双强度=0.0；
用于（常数自动和交点：交点）{
//虚拟类交集的函数被强度多面体或强度多边形的函数覆盖
强度=交叉口->调制强度（强度）；
}
// ...
返回界面一般都很好：

class Ray;

struct Intersection
{
    virtual ~Intersection() = default;
    virtual double modulate_intensity(double intensity) = 0;
};
struct Intersection_Polygon : Intersection
{
    double modulate_intensity(double intensity) override {/**/}
};
struct Intersection_Polyhedron : Intersection
{
    double modulate_intensity(double intensity) override {/**/}
};

struct Object
{
    virtual ~Object() = default;
    virtual std::shared_ptr<Intersection> get_intersection(const Ray&) = 0;
};

struct Polygon : Object
{
    std::shared_ptr<Intersection> get_intersection(const Ray&) override {
        return std::make_shared<Intersection_Polygon>();
    }
};
struct Polyhedron : Object
{
    std::shared_ptr<Intersection> get_intersection(const Ray&) override {
        return std::make_shared<Intersection_Polyhedron>();
    }
};

类射线；
结构交点
{
virtual~Intersection（）=默认值；
虚拟双调制_强度（双强度）=0；
};
结构交集\多边形：交集
{
双调制_强度（双强度）覆盖{/**/}
};
结构交点\多面体：交点
{
双调制_强度（双强度）覆盖{/**/}
};
结构对象
{
virtual~Object（）=默认值；
虚拟std：：共享ptr get_交叉点（const-Ray&）=0；
};
结构多边形：对象
{
std:：共享\u ptr获取\u交叉点（const-Ray&）覆盖{
返回std:：make_shared（）；
}
};
结构多面体：对象
{
std:：共享\u ptr获取\u交叉点（const-Ray&）覆盖{
返回std:：make_shared（）；
}
};

<>返回类型可以用协方差来改进，但是C++只处理引用和非智能指针，所以需要一些BO。
struct Object
{
    virtual ~Object() = default;
    std::shared_ptr<Intersection> get_intersection(const Ray& ray)
    {
        return std::shared_ptr<Intersection>{get_intersection_ptr(ray)};
    }
protected:
    virtual Intersection* get_intersection_ptr(const Ray&) = 0;
};

struct Polygon : Object
{
    std::shared_ptr<Intersection_Polygon> get_intersection(const Ray& ray)
    {
        return std::shared_ptr<Intersection_Polygon>{get_intersection_ptr(ray)};
    }
protected:
    Intersection_Polygon* get_intersection_ptr(const Ray&) override {
        return new Intersection_Polygon();
    }
};

template <typename IntersectionType>
struct ObjectT : Object
{
    std::shared_ptr<IntersectionType> get_intersection(const Ray& ray)
    {
        return std::shared_ptr<IntersectionType>{get_intersection_ptr(ray)};
    }
protected:
    IntersectionType* get_intersection_ptr(const Ray&) override {
        return new IntersectionType();
    }
};

struct Polygon : ObjectT<Intersection_Polygon> {};
struct Polyhedron : ObjectT<Intersection_Polyhedron> {};