C++：声明IF／EFE:VAR在这个范围内没有声明 我不理解C++中的一些东西，GCC不喜欢我怎么继续下去。 我做到了：

我得到了这个错误：

file.C:211:16: warning: unused variable 'main' [-Wunused-variable]
file.C:213:15: warning: unused variable 'main' [-Wunused-variable]
file.C:219:9: error: 'main' was not declared in this scope

我不能在标题中声明main，因为他的类型依赖于fModeMdi boolean。

---

我怎样才能解决这个问题呢？

在if语句之前定义变量，并在其中赋值如何

MyFirstClass* main = 0; // use nullptr if you have access to a C++11 compiler

if (!fModeMdi)
    main = (MyFirstClass*) fMaino;
else
    main = (MySecondClass*) fMdio;

---

因为您在if语句中定义了它，所以在它之后，变量已经超出范围，无法再被引用。

在if语句之前定义变量，然后在它内部赋值如何

MyFirstClass* main = 0; // use nullptr if you have access to a C++11 compiler

if (!fModeMdi)
    main = (MyFirstClass*) fMaino;
else
    main = (MySecondClass*) fMdio;

---

由于您在if语句中定义了它，在它之后，变量已经超出范围，无法再被引用。

以下操作应该可以正常工作。在C++中，变量的范围在括号{}内，也就是说，它只在括号内被识别。一旦你离开，程序就不知道了

MyFirstClass* main =0; 
MySecondClass* main2 =0; 

if (!fModeMdi)
            main = (MyFirstClass*) fMaino;
    else
            main2 = (MySecondClass*) fMdio;

---

以下几点应该行得通。在C++中，变量的范围在括号{}内，也就是说，它只在括号内被识别。一旦你离开，程序就不知道了

MyFirstClass* main =0; 
MySecondClass* main2 =0; 

if (!fModeMdi)
            main = (MyFirstClass*) fMaino;
    else
            main2 = (MySecondClass*) fMdio;

---

C++是一种静态类型的语言

    int i = main->GetNum();

编译器必须在编译时静态地知道main的类型，因此得名。不能使main的类型依赖于某个值fModeMdi，该值仅在运行时已知。如果每个类包含一个方法GETNUM和其他的，在IF语句之后使用，那么您可以考虑将它们移到基类，例如：

class MyBaseClass {
public:
    virtual int GetNum() = 0;
}

class MyFirstClass : public MyBaseClass {
    // ...
};


class MySecondClass : public MyBaseClass {
    // ...
};

MyBaseClass* main = 0;
if (!fModeMdi)
            main = (MyFirstClass*) fMaino;
    else
            main = (MySecondClass*) fMdio;
    ...
    ...

这是合法的

    int i = main->GetNum();

---

实际上，适当的设计将通用方法移动到基类可能会完全消除对这个if语句的需要。这就是所谓的多态性，它的全部目的是消除对这些if或switch语句的需要。

C++是一种静态类型语言，在这一行

    int i = main->GetNum();

编译器必须在编译时静态地知道main的类型，因此得名。不能使main的类型依赖于某个值fModeMdi，该值仅在运行时已知。如果每个类包含一个方法GETNUM和其他的，在IF语句之后使用，那么您可以考虑将它们移到基类，例如：

class MyBaseClass {
public:
    virtual int GetNum() = 0;
}

class MyFirstClass : public MyBaseClass {
    // ...
};


class MySecondClass : public MyBaseClass {
    // ...
};

MyBaseClass* main = 0;
if (!fModeMdi)
            main = (MyFirstClass*) fMaino;
    else
            main = (MySecondClass*) fMdio;
    ...
    ...

这是合法的

    int i = main->GetNum();

---

实际上，适当的设计将通用方法移动到基类可能会完全消除对这个if语句的需要。这就是所谓的多态性，其全部目的是消除对这些if或switch语句的需要。

在循环中为i赋值

int i;
if (!fModeMdi){
        MyFirstClass* main = (MyFirstClass*) fMaino;
        i = main->GetNum();
}else{
        MySecondClass* main = (MySecondClass*) fMdio;
        i = main->GetNum();
}

---

在循环中指定i的值

int i;
if (!fModeMdi){
        MyFirstClass* main = (MyFirstClass*) fMaino;
        i = main->GetNum();
}else{
        MySecondClass* main = (MySecondClass*) fMdio;
        i = main->GetNum();
}

如果MyFirstClass和MySecondClass是通过继承联系在一起的，那么您可以按照@unkulunkulu在其回答中的建议进行操作

但是，如果MyFirstClass和MySecondClass是不相关的类，则可以将模板用作：

if (!fModeMdi)
{
    do_work(static_cast<MyFirstClass*>(fMaino));
}
else
{
    do_work(static_cast<MySecondClass*>(fMaino));
}

请注意，即使它们是相关的，这个模板解决方案也可以工作

如果MyFirstClass和MySecondClass是通过继承关联的，那么您可以按照@unkulunkulu在其回答中的建议进行操作

但是，如果MyFirstClass和MySecondClass是不相关的类，则可以将模板用作：

if (!fModeMdi)
{
    do_work(static_cast<MyFirstClass*>(fMaino));
}
else
{
    do_work(static_cast<MySecondClass*>(fMaino));
}

请注意，即使它们是相关的，这个模板解决方案也可以工作

如果main可能不是多态的，那么看来正确的解决方案是函子或。并提供这些图书馆

忽略下面程序中的内存泄漏，我们将对象new A或new B绑定到它们各自的GetNum调用，并将它们包装在可调用对象f中。需要时我们叫f

#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <iostream>

class A {
     public:
    int GetNum() { return 0; }
};

class B {
    public:
    int GetNum() { return 0; }
};

int main(int args, char** argv)
{

    bool p = true;
    boost::function<int()> f;
    int i;

    if ( p ) {
        f = boost::bind(&A::GetNum, new A());
    }
    else {
        f = boost::bind(&B::GetNum, new B());
    }

    i = f();

    std::cout<<i<<std::endl;

    return 0;
}

如果main可能不是多态的，那么看起来正确的解决方案是函子或。并提供这些图书馆

忽略下面程序中的内存泄漏，我们将对象new A或new B绑定到它们各自的GetNum调用，并将它们包装在可调用对象f中。需要时我们叫f

#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <iostream>

class A {
     public:
    int GetNum() { return 0; }
};

class B {
    public:
    int GetNum() { return 0; }
};

int main(int args, char** argv)
{

    bool p = true;
    boost::function<int()> f;
    int i;

    if ( p ) {
        f = boost::bind(&A::GetNum, new A());
    }
    else {
        f = boost::bind(&B::GetNum, new B());
    }

    i = f();

    std::cout<<i<<std::endl;

    return 0;
}

---

这两个类是否有继承层次结构？因此应该提供类定义，以及使用main的一些上下文。我们无法猜测您的代码是如何实现的。这两个类是否有继承层次结构？因此应该提供类定义，以及使用main的一些上下文。我们无法猜测您的代码是如何实现的。如果MySecondClass不是直接或间接从MyFirstClass派生的呢？只要我们可以假设可以将MySecondClass*强制转换为MyFirstClass*。是的，您是对的。我假设，由于OP使用两个以相同方式命名的变量，因此这些类型是兼容的。如果他提供了这些类的定义，也许可以使用另一种方法。@MFONTANI:请参阅我的解决方案。@MFONTANI:请注意，c样式转换在这里可能不起作用。如果涉及的对象是多态类，那么这里需要的是动态转换。如果MySecondClass不是直接或间接从MyFirstClass派生的呢？只要我们可以假设可以将MySecondClass*转换为MyFirstClass*。是的，你是对的。我假设，由于OP使用两个同名变量，thos

---

e型是相容的。如果他提供了这些类的定义，也许可以使用另一种方法。@MFONTANI:请参阅我的解决方案。@MFONTANI:请注意，c样式转换在这里可能不起作用。如果所涉及的对象是多态类，那么这里需要的是动态转换。你真快！天哪，这几乎是我要发布的逐字逐句的内容。你真快！