使用之前在 if 语句中定义的变量

Question

int main() {
    if(i = 0) {
        myclass1 a = "Example1";
    }
    else {
        myclass2 a = "Example2";
    }
    cout << a << endl;
}

我知道一种方法是在块外定义它，但如果在检查i 的条件之前我还没有确定a 的类型怎么办？

Answer 1

C++ 是一种静态类型语言，需要在编译时知道代码中使用的变量类型。

没有办法编写一个 C++ 程序，其中编译了像 std::cout << a; 这样的语句，并且直到运行时才知道 a 的类型。

为此，您需要一种动态类型语言，例如 Python 或 JavaScript。

Answer 2

我自己也有这样的代码，而实际上我正在尝试相同代码的不同变体。然后我意识到最好的选择是使用预处理器#if，它解决了我的问题：

#define VARIATION 2

...

#if VARIATION == 1
    myclass1 a = "Example1";
#else
    myclass2 a = "Example2";
#endif

我知道它可能无法解决您的问题，但至少这是一种解决方法。

Answer 3

如果是这个特定的问题，我认为这会容易得多

int main(){
    if(i == 0)          //You wrote i=0 !! silly mistake
        std::cout << myclass1("Example1");
    else
        std::cout << myclass2("Example2");
}

或者你可以选择

template<class T>
void foo(T out)
{
    std::cout << out;
}

int main()
{
    if( i==0 )
        foo(myclass1("ex1"));
    else
        foo(myclass2("ex2"));
}

否则

this 是要走的路 我建议不要在这里使用 cout，因为它可能没有重载来接受您的用户定义的类。

Answer 4

这绝对需要多态性，如果您想让它更优雅一点，可以选择使用factory pattern。工厂模式并不神奇，它只是将if 隐藏在一个漂亮的包装器中。

为什么不采用另一种方法，例如std::variant 基本上是伪装的union？好吧，如果您能够以相同的名称存储不同种类的东西，甚至是 any 种类 (std::any)，那就太好了，但它并不是很有用，因为您也 em> 想对对象做一些有意义的事情。如果您想做完全不同的、不相关的事情，那么您也可以使用 if 块范围内的不同对象（并且使用完全不同的代码）。但是，如果您想对不同的对象执行相同或相似的操作，那么它们（通常）需要是相同或相关的类型。

不同类型通常没有相同的数据成员或相同的可公开访问的成员函数。因此，在不同类型的源代码级别上做同样的事情通常是行不通的（除非巧合）。

但是如果两个类在它们的接口上确实有相同的子集，并且您希望能够以一种或另一种方式互换，那么从基类继承是最自然的，并且惯用的事情。这就是发明多态性的目的。使用惯用的东西。

（您可以通过模板助手在不同的、不相关的类型上调用具有相同名称的函数获得相同的净效果，并假设您使用的名称存在，这将正常工作，但它的风格几乎没有那么好，并且通过两次实例化函数会导致巨大的膨胀）。

Answer 5

我会尝试给你一个实际的答案，假设你已经习惯用 JavaScript 或其他东西做这类事情，并且只是尝试用 C++ 编写代码。

首先，您应该了解在 C++ 中，cout << a。实际上可以根据a 的类型调用一个完全不同的 方法。因此，当您对该类型一无所知时，写cout << a 没有任何意义。事实上，你对a 什么都做不了，除非你对 C++ 的类型有足够的了解来决定你想调用哪个方法或运算符。

如果你的两个类都有一个可接受的公共基础，那么你可以这样做：

int main() {
    base_class *pa;
    my_class1 a1;
    my_class2 a2;

    if(i = 0) {
        a1 = "Example1";
        pa = &a1;
    }
    else {
        a2 = "Example2";
        pa = &a2;
    }
    cout << *pa << endl;
}

请注意，当您编写cout << *pa 时，您不一定调用cout << a 将使用的相同方法。在第一种情况下，您调用的方法知道如何输出base_class 的所有子类，而在第二种情况下，您可能正在调用专门为myclass1 或myclass2 编写的方法。

当没有可接受的基类时，我们就不要在 C++ 中编写类似的代码：

int main() {
    if(i = 0) {
        myclass1 a = "Example1";
        cout << a << endl;
    }
    else {
        myclass2 a = "Example2";
        cout << a << endl;
    }
}

请记住，在这些情况下调用的两个方法可能是完全不同的方法。这就像打电话给cout.printClass1(a) 和cout.printClass2(a)。当 C++ 可以根据参数类型确定要调用哪个方法时，您可以为完全不同的方法使用相同的名称。

当您编写 cout.callWhatever(a) 时，JavaScript 没有任何魔法可以自动在 printClass1 和 printClass2 之间进行选择，C++ 也没有。在两种语言中，如果您必须为myclass1 和myclass2 调用完全不同的方法，那么您编写不同的调用。

Answer 6

你可以试试polymorphism。 假设myclass1 和myclass2“实现”了一个名为myclass 的类，你可以这样做：

int main() {
    myclass*a;
    if (i=0) {
        a = new myclass1("Example1");
    } else {
        a = new myclass2("Example2");
    }
    cout<<*a<<endl;
}

如果您以后想主动使用myclass1 或myclass2 类型，可以使用dynamic_cast，但根据您的需要以及您在继承类和基类中实现的行为，可能不会有必要。

注意我在这里使用了一个原始指针，因为它是一个短暂的对象，很明显程序已经结束。我鼓励您阅读有关smart pointers 的信息并适当地使用它们以避免memory leaks。注意某些平台中的内存泄漏会持续到重新启动后，可能需要手动释放（删除）分配的内存。更多关于here.

Answer 7

int main() {
    auto call = [](auto a) {
        std::cout << a << std::endl;
    };

    if(i = 0)
        call(myclass1 { "Example1" });
    else 
        call(myclass2 { "Example2" });
}

Answer 8

如果您能够使用c++17，您可以使用std::variant 或std::any，以防您的类型没有公共基类。这些类是任何或指定类型的类型安全容器。 std::variant 的示例如下：

#include <iostream>
#include <string>
#include <variant>

int main() {
    bool input = false;
    std::cin >> input;

    std::variant<int, long, double, std::string> myVariant;
    if(input)
        myVariant = "Example1";
    else
        myVariant = 3.14;

    std::visit([](auto&& arg) { std::cout << arg << std::endl; }, myVariant);
}

除了c++17，您还可以使用boost::variant 或boost::any。