标签: polymorphism

我已经编写了一些 VSTO (2003) 代码，这些代码根据邮件项目的附件成功地应用了一些强制性主题行更改。该代码是为在 microsoft.office.interop.outlook.mailitem 上操作而编写的但是，我需要相同的代码来操作其他类型，例如 microsoft.office.interop.outlook.appointmentitem（实际上它需要为任何用户可以发送具有主题的内容）。

假设 Outlook 项目类型具有主题属性、附件属性和保存方法，我该如何编写适用于所有相关 interop.outlook 类型的代码。

我尝试通过反射解决这个问题，但 GetProperty 正在返回 null 所以我不能在它上面使用 GetValue

? mi.GetType().GetProperty("主题")
空值

?(mi as Microsoft.Office.Interop.Outlook.MailItem).主题
“考试科目”

似乎没有我可以投射到的通用 Outlookitem 类来执行此操作。正确的做法是什么？

编辑：为了澄清我的代码是这样开始的......

    void Application_ItemSend(object Item, ref bool Cancel) 
    {
            如果（项目是 Microsoft.Office.Interop.Outlook.MailItem） 
            {
                Microsoft.Office.Interop.Outlook.MailItem currentItem = 
                    项目为 Microsoft.Office.Interop.Outlook.MailItem；

然后对 currentItem 执行操作（包括传递给当前使用 Microosft.Office.Interop.Outlook.MailItem 属性键入的各种函数。我希望它们处理“Microsoft.Interop.Outlook.somethingsendable”

我有一对类FS和DS,它们都来自另一个类S.我有一个函数,我传入一个S*(即FS或DS),它进一步调用另一个函数传入相同的S*.在这个最终函数中,我需要根据S是FS还是DS来具有不同的行为,但是由于它在关键路径上,所以希望在编译时解析该分支.我怎样才能做到这一点？涉及元编程和/或constexpr的东西我觉得 - 我不想为每个传递进行虚拟调用

为简洁起见,省略了无关的细节

class S {};
class FS : public S {};
class DS : public S {};

void func_2(Space *s) {
     // common code
     // branch based on lowest type of s
     // common code
}

void func_1(Space *s) {
    // common code
    func_2(s);
}

如果我错了,请纠正我,但关键字"auto"可以解决多态发明要解决的所有问题.

而不是声明类A的虚函数func,当我们从它继承B类时,我们可以说函数func正在接收自动参数,它将知道触发什么情况.

我错过了什么？

我试图找出代码中编译错误的原因:

class A
{
    public:
    virtual ~A(){}
};

class B: public A
{
    public:
    virtual ~B(){}
};

class D: public B
{
    public:
    virtual ~D(){}
};

template <class X, class Y>
X* fun(X* p){return dynamic_cast<Y*>(p);}

int main()
{
    A* q = dynamic_cast<B*>(new D());
    A* p = fun<D,B>(new D());
}

对我来说,似乎指针q和p应该指向相同的类型但是对于p我收到编译器错误,说"无效转换从'B*'到'D*'".我唯一没有得到错误的是当我以B的子类为D(因此p是空指针)的方式更改类时.谁能帮我理解为什么会这样？

基本上我有这个练习:使用列表推导,写一个多态函数:

split :: [(a, b)] -> ([a], [b])

它将一对(任何类型的)列表转换为一对列表.例如,

split [(1, 'a'), (2, 'b'), (3, 'c')] = ([1, 2, 3], "abc")

这是我编写函数的方式,但它不起作用:

split :: [(a, b)] -> ([a], [b])
split listOfPairs = (([a | a <- listOfPairs]), ([b | b <- listOfPairs]))

有人可以解释为什么我的解决方案不起作用？谢谢!

我目前有以下结构

class A

class B : public A

class C : public A

我在A和中定义了虚方法，B并且C正在重写它们。该方法是那种

bool C::CheckCollision(shared_ptr<B> box);

bool B::CheckCollision(shared_ptr<C> triangle);

我还有一个向量，shared_ptr<A>其中存储了所有游戏对象。问题是我无法执行以下操作

for (int i = 0; i < objects.size(); i++)
{
    for (int j=i; j < objects.size(); j++
    {
        objects[i]->CheckCollision(objects[j]);
    }

}

我收到一个错误消息，说参数列表与重载函数不匹配。在尝试传递shared_ptr<A>期望值时，shared_ptr<B>还是很有道理的shared_ptr<C>，但是如何解决这个问题呢？还有另一种方法吗？

我正在可视化Mandelbrot集以及其他一些分形，并且有很多重复的代码，但是没有代码重用。

我正在使用的功能之一如下：

/**
 * determines whether a pixel lies in the set
 * @params x, y - x and y coordinates on R/I axes
 * @param c - a complex number
 */
void calculateSet(int x, int y, Complex c) {
    Complex z = c.clone();
    int n = 0;
    for (; n < maxDepth; n++) {
        if (z.dis() > 4) { break; }
        z = z^2 + c;
    }
    // some code using n to color the set
}

这遵循Mandelbrot集：

z_(n+1) …

[编辑]：这个问题与我无法控制的类型有关。因此，使它们无法继承超类或实现接口是不可能的。我希望能够做到这一点而无需包装类型。

我想编写一个方法，将包含特定方法的所有对象接受为参数。

例如，我们有2种完全不同的类型，它们都包含get具有相同签名的方法：

public class TypeOne {
  public int get() { /* Some implementation */ }
}

public class TypeTwo {
  public int get() { /* Some other implementation */ }
}

如何编写可以接受这两种类型的方法？

public static int callGetOnObject(GettableObject gettableObject) {
  return gettableObject.get();
}

我目前有一个基类Env，它是一个接口，并且我有几个派生类。

class Env

{
    public:

        //method in question
        virtual std::tuple<Eigen::VectorXf,float,bool,std::string> step(const //what goes here?//)=0;

        virtual ~Env(); //virtual destructor
};

派生类的示例如下（标题）

class MountainCar: public Env

{
    public:

        MountainCar();
        std::tuple<VectorXf,float,bool,std::string> step(const int) override;

};

现在，设计是所有环境都必须从Env继承。但是，我想强制所有环境来实现step（）方法，这就是为什么基本Env中的step方法是纯虚拟方法的原因。

但是，每个派生的Env在step方法中可以采用不同的参数类型，并且这应该是有效的替代（这些有效类型来自固定的已知集合）例如，mountain car用int参数定义了它。另一个环境CartPole使用VectorXf作为step参数。

最初，我使基类成为带有参数U的模板类，然后将U传递给step方法。然后，派生类用于继承模板实例，例如从Env继承的MountainCar示例。但是，问题在于所有派生类都继承自基类的不同实例，并且我不能再将公共基指针用于多态。

如何设计具有C ++ 11功能的系统？

我有一个下面的程序：

class SuperClassWas {
    void myM() throws NullPointerException{
        System.out.println("Super class myM called.");
    }
}

class SubClassWas extends SuperClassWas{
    void myM() throws RuntimeException{
        System.out.println("Sub class myM called.");
    }
}

public class MethodOveridingWithException {
    public static void main(String[] args) {
        SuperClassWas obj = new SubClassWas();
        obj.myM();
    }
}

按照规则

如果SuperClass声明了异常，则SubClass只能声明SuperClass声明的异常的子级异常，而不能声明其他任何异常。

在我的程序中，超级类方法myM扩展了NullPointerException，子类重写方法myM扩展了RuntimeException，当我尝试运行程序时，它运行良好。问题是为什么？理想情况下，它不应工作，因为RuntimeException它不是的子类NullPointerException。

如果我错了，请纠正我。