C++ 取消对对象的空心指针的引用

给出以下代码作为最低工作示例：

#include <iostream>

class Object_A
{
public:
    int attribute_a,attribute_b;
    
    Object_A(int a,int b){
        this->attribute_a = a;
        this->attribute_b = b; 
    }
    
    int object_method(){
        std::cout << "Hello from Object A: " << std::endl;
        return (this->a + this->b);
    }
    
};

class Object_B
{
public:
    int attribute_c, attribute_d;
    
    Object_B(int c,int d){
        this->attribute_c = c;
        this->attribute_d = d; 
    }
        
    int object_method(){
        std::cout << "Hello from Object B" << std::endl;
        return (this->c + this->d);
    }

};


class Object_Omega
{
public:
        
    Object_A alpha;
    Object_B beta;
    
    Object_Omega (Object_A first, Object_B second):
        alpha(first),
        beta(second)
    {}

    int foobar(int a){ return a; }
    
};

void according_to_user_input(bool input,Object_Omega obj)
{
    
    void * either_A_or_B;
    
    if (input){ either_A_or_B = & obj.alpha; }
    else      { either_A_or_B = & obj.beta;  }
    
                       /* problem here */
    for(int i = 0; i < either_A_or_B->object_method(); i++)
    {
        std::cout << i << std::endl;
    }

}

int main()
{   
    /* this happens somewhere */
    Object_A new_A = Object_A(1,2);
    Object_B new_B = Object_B(3,4);
    Object_Omega W = Object_Omega(new_A, new_B);

        
    according_to_user_input(true/*false*/, W);
    
    return 0;
}

#包括
类对象_A
{
公众：
int属性_a，属性_b；
对象_A（int A，int b）{
该->属性_a=a；
此->属性_b=b；
}
int对象_方法（）{
std：：cout b）；
}
};
类对象
{
公众：
int属性_c，属性_d；
对象_B（int c，int d）{
此->属性_c=c；
该->属性d=d；
}
int对象_方法（）{
标准：cout d）；
}
};
类对象_ω
{
公众：
物体Aα；
对象Bβ；
Object_Omega（Object_A第一，Object_B第二）：
阿尔法（第一），
贝塔（秒）
{}
intfoobar（inta）{返回a；}
};
根据用户输入无效（布尔输入，对象ωobj）
{
无效*_A_或_B；
如果（输入）{u A_或u B=&obj.alpha；}
else{u A_或u B=&obj.beta；}
/*这里有问题*/
对于（inti=0；iobject\u method（）；i++）
{
std：：cout您不能通过指向
void
的指针进行间接操作。也不需要指向
void
的指针

最简单的解决方案是：

int number = 1;
std::cout << input
    ? obj.alpha.object_method(number)
    : obj.beta.object_method(number);

int number=1；
std:：cout这对于
void*
不是一个好的用法，如果像您所评论的那样，您不能利用继承，并且实际问题不仅仅是控制台输出，那么您仍然可以使用函数模板使其通用

template <class T>
void according_to_user_input(T &obj)
{
    std::cout << obj.object_method();
}

模板
根据用户输入无效（T&obj）
{
std:：cout我不确定您的示例是否具有代表性，是否允许您使用C++11，但通常我会使用一个公共基类的继承，即智能指针（例如
std:：shared_ptr
）和
virtual
函数来避免这种情况。如有必要，您可以使用
std:：static\u pointer\u cast
。类似于我昨天给出的答案。我建议OP重写代码，如果可能的话，可以使用多态性来代替。@2b-t基于这个问题，OP似乎已经意识到了这一点。不幸的是，所说的
我一直在研究的代码显示了这种行为，而不是继承关系。
。您好@eeronika。感谢您的回复。可能我没有正确解释。我将编辑此帖子，以便更好地解释我希望做的事情。的确，鉴于我给出的示例，问题可以通过简单的方法解决if then case在用户输入上。@eerorika I更新了该示例。希望它现在更有意义。@ex1led模板是一种生成类和函数的方法，除了作为模板参数提供的类型或编译时值之外，这些类和函数在其他方面是相同的。因此，如果要对类型a的对象执行X操作，并且要执行对于不相关类型B的对象使用相同的X，则模板是生成X（a）和X（B）而无需重复的方便方法。这有时称为“通用编程”.哦，模板。这可能是我需要的！我没有考虑到这一点。我对该语言没有太多经验，但我确实认为，根据我所读的内容，这可能也是解决我问题的一个方法。我会研究它。谢谢。
template <class T>
void according_to_user_input(T &obj)
{
    std::cout << obj.object_method();
}

if (input)
    according_to_user_input<Object_A>(W.alpha);
else
    according_to_user_input<Object_B>(W.beta);