标签: base-class

我有各种类型的碰撞器类（SphereCollider、AABBCollider 等），它们都继承自基类 Collider。我使用指向基类的指针将它们存储在 std::vector 中。

std::vector<std::shared_ptr<Collider>> colliders;

然后我有各种函数来确定对撞机是否彼此相交。

bool Colliding(const SphereCollider& colliderOne, const SphereCollider& colliderTwo);
bool Colliding(const AABBCollider& colliderOne, const AABBCollider& colliderTwo);
bool Colliding(const AABBCollider& colliderOne, const SphereCollider& colliderTwo);
bool Colliding(const SphereCollider& colliderOne, const AABBCollider& colliderTwo);

我的想法是简单地遍历碰撞器向量，然后将每个碰撞器与列表中的所有其他碰撞器进行比较。

for (unsigned int a = 0; a < colliders.size(); ++a)
{
    for (unsigned int b = a + 1; b < colliders.size(); ++b)
    {
        // Store the two colliders we're current comparing
        std::shared_ptr<Collider> colliderOne = colliders[a];
        std::shared_ptr<Collider> colliderTwo = colliders[b];

        // Somehow cast …

众所周知，在Python中一切都是对象。我想知道的是是否有可能创建一个“对象” x，以便isinstance(x, object)返回False. I suspect it's possible with sufficient abuse of the CPython API, though achieving this with pure Python would be even more interesting.

最初我认为旧式类会返回，False因为对象层次结构可能不完全适用，但似乎isinstance(x, object)确实True适用于旧式类的实例。

虽然这主要是理论上的兴趣，但如果 Python 允许创建与基本object类型断开连接的新对象层次结构，它可能会很有趣（或危险）。

我知道通过继承基类。基类中的所有函数也可以在派生类中访问。但是它是如何以另一种方式工作的，这意味着在子类中定义的函数可以在基类中访问。

我用一个例子尝试了上面的内容。它工作得很好。但这怎么可能。我无法理解工作背后的逻辑。

class fish:

    def color(self):
        # _colour is a property of the child class. How can base class access this?
        return self._colour  


class catfish(fish):

    _colour = "Blue Cat fish"

    def speed(self):
        return "Around 100mph"

    def agility(self):
        return "Low on the agility"

class tunafish(fish):

    _colour = "Yellow Tuna fish"

    def speed(self):
        return "Around 290mph"

    def agility(self):
        return "High on the agility"

catfish_obj = catfish()
tunafish_obj = tunafish()

print(catfish_obj.color())
print(tunafish_obj.color())

我知道实例正在传递并且全部通过 self 传递，但是子类的详细信息在逻辑上不应在基类中访问，对吗？！

我刚刚读过一篇关于通用实体基类的文章。简单地说，如果我没有错的话，后面的主要思想是在一个接口中收集所有通用的、非实体特定的字段，而不是在主要实体中实现它。这将是一篇 TL:DR；让我们看一些代码。

这是基本实体接口，它是另一个接口的通用实现

public interface IEntity : IModifiableEntity
{
    object Id { get; set; }
    DateTime CreatedDate { get; set; }
    DateTime? ModifiedDate { get; set; }
    string CreatedBy { get; set; }
    string ModifiedBy { get; set; }
    byte[] Version { get; set; }
}

public interface IEntity<T> : IEntity
{
    new T Id { get; set; }
}

这是它在抽象类中的实现

public abstract class Entity<T> : IEntity<T>
{
    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public T Id { get; set; }
    object IEntity.Id
    { …

我有一个类型特征和概念，用于检查 an 是否std::variant可以保存给定的类型T。现在我有一个variant2派生自 的类型std::variant，并且我想将该类型特征与新variant2类型一起使用。我怎样才能优雅地完成这个任务呢？

这不起作用（演示）：

#include <variant>
#include <string>
#include <iostream>
#include <concepts>
#include <type_traits>

template<typename T, typename Variant>
struct variant_type;

template<typename T, typename... Args>
struct variant_type<T, std::variant<Args...>> 
    : public std::disjunction<std::is_same<T, Args>...> {};

template<typename T, typename Variant>
concept is_variant_type = variant_type<T, Variant>::value;

template <typename... Ts>
struct variant2 : public std::variant<Ts...> {
};

variant2<std::monostate, int, bool, std::string> var;

int main() {
    using T = std::string;

    if constexpr (is_variant_type<T, decltype(var)>) …

我想专门调用基类方法; 什么是最简洁的方法呢？例如:

class Base
{
public:
  bool operator != (Base&);
};

class Child : public Base
{
public:
  bool operator != (Child& child_)
  {
    if(Base::operator!=(child_))  // Is there a more concise syntax than this?
      return true;

    // ... Some other comparisons that Base does not know about ...

    return false;
  }
};

我经常使用以下方法将对象链接到父母:

 Video parent;

有时我的对象可以是不同对象类型的子对象,所以我:

 int parentType;
 Video parentVideo; // if parent == VIDEO then this will be used
 Audio parentAudio; // if parent == AUDIO then this will be used

有没有更好的办法？如何使用可以是不同类型实例的变量？

编辑:当然,如果视频和音频继承自相同的基类(例如媒体),我可以这样做:

 Media parent;

但是,如果父母不继承同一个基类怎么办？

class Base
    {
        //...
        public int i = 5;
    }

class Drifted : Base
{
    //...
    public int b = 10;
}

Base ObjectOrReference = new Drifted();

所以Base ObjectOrReference;是对基类型的引用.当我们写Base ObjectOrReference = new Drifted();它成为对象因为使用'new'我们为它分配内存？或者它仍然引用,如果它是真的,它有什么类型？直接的问题是:"是ObjectOrReference对象吗？"

在下面的设置中,我如何才能使它能够引用Bar派生类中的名称Derived<T>？

template <typename T> struct Foo
{
    template <typename U> struct Bar { };
};

template <typename T> struct Derived : Foo<T>
{
    // what goes here?

    Bar<int> x;  // Error: 'Bar' does not name a type
};

我试过了using Foo<T>::Bar;,但这没有用.是否有任何类型的using声明可以使派生类知道嵌套基本模板的名称,以便我可以保持简单的声明Bar<int> x？

我知道我可以说typename Foo<T>::template Bar<int> x;,但我有很多这样的情况,我不想用这么多的冗长不必要地加重代码.我也有很多不同的" ints",因此typedef每个嵌套模板实例的a也是不可行的.

此外,我不能在此时使用GCC 4.7,也不能使用C++ 11,因此会喜欢没有模板别名的"传统"解决方案.

我有一些代码,它将演示Liskov替换,但我很困惑base关键字在2个参数上做了什么.谁能解释一下？

class Rectangle
{
    public Rectangle(int width, int height)
    {
        Width = width;
        Height = height;
    }
    public virtual int Height {get;set;}
    public virtual int Width {get;set;}
    public int Area
    {
        get { return Height*Width }
}

现在,对于使用2个参数继承基类的square类.我也很好奇为什么下一个方法广场(int)可以在基类中使用不同名称的方法

private class Square : Rectangle
{
    public Square(int size) : base(size, size) {} ///here is my confusion
    public override int Width
    {
        get {return base.Width}
        set { base.Width = value; base.Height = value}
    }
    public override int Height
    { /// same thing …