在C或C+中是否可能+；在另一个函数中创建函数？ 有人能告诉我，C或C++中是否有可能？ void fun_a(); //int fun_b(); ... main(){ ... fun_a(); ... int fun_b(){ ... } ... }

或者类似的东西，比如函数中的类

---

感谢您的回复，

无法在函数中声明函数。但是，你可以在一个命名空间内声明一个函数，或者在C++中的一个类中声明。

< P> C++不支持嵌套函数，但是你可以使用类似的东西。

NO，但是在C++ 0x中你可以再花几年来完全支持。本标准在撰写本文时并不完整

-编辑-

对 如果你能使用MSVC 2010。我成功地运行了下面的代码

void test()
{
 []() { cout << "Hello function\n"; }();
 auto fn = [](int x) -> int { cout << "Hello function (" << x << " :))\n"; return x+1; };
 auto v = fn(2);
 fn(v);
}

（我在project working arguments部分中编写了c:\dev\loc\uniqueName.txt，并复制粘贴了此结果）

c-对gcc是

---

C++-No.

不在标准C中，但

gcc

和

clang

支持它们作为扩展。虽然C和C++都禁止嵌套函数，但是一些编译器支持它们（例如，如果内存服务，GCC可以，至少用正确的标志）。不过，嵌套函子的可移植性要高得多。

您要寻找的术语是嵌套函数。标准C和C++都不允许嵌套函数，但是GNU C允许它作为扩展。这是一个很好的例子。

Clang/Apple正在研究C语言中的匿名函数“blocks”：-D

^（void）{printf（“hello world\n”）；}

---

不幸的是，在C/C++中没有嵌套函数。

没有，而且至少有一个原因使允许它会使事情复杂化。嵌套函数通常需要访问封闭范围。这使得“堆栈”不再可以用堆栈数据结构表示。相反，需要一棵完整的树

考虑下面的代码，它确实按照KennyTM的建议在gcc中编译

#include <stdio.h>

typedef double (*retdouble)();

retdouble wrapper(double a) {
  double square() { return a * a; }

  return square;
}

int use_stack_frame(double b) {
  return (int)b;
}

int main(int argc, char** argv) {
  retdouble square = wrapper(3);
  printf("expect  9 actual %f\n", square());
  printf("expect  3 actual %d\n", use_stack_frame(3));
  printf("expect 16 actual %f\n", wrapper(4)());
  printf("expect  9 actual %f\n", square());
  return 0;
}

请注意，最后一行调用了“square”函数，但它访问的“a”值在wrapper（4）调用期间被修改。这是因为并非每次调用“包装器”都会创建一个单独的“堆栈”框架

---

请注意，这些类型的嵌套函数实际上在其他支持它们的语言中非常常见，如lisp和python（甚至是最新版本的Matlab）。它们带来了一些非常强大的函数式编程功能，但它们阻止了使用堆栈来保存本地范围帧。

哇，我很惊讶没有人说是！自由函数不能嵌套，但函子和类通常可以嵌套

void fun_a();
//int fun_b();
...
main(){
   ...
   fun_a();
   ...
   struct { int operator()() {
     ...
   } } fun_b;

   int q = fun_b();
   ...
}

可以给函子一个构造函数，并传递对局部变量的引用，以将其连接到局部作用域。否则，它可以访问其他本地类型和静态变量。但是，本地类不能作为模板的参数。

您可以在函数中嵌套，在这种情况下，该类只能由该函数访问。然后，可以将嵌套函数作为本地类的成员编写：

#include <iostream>

int f()
{
    class G
    {
    public:
        int operator()()
        {
            return 1;
        }
    } g;

    return g();
}

int main()
{
    std::cout << f() << std::endl;
}

从gcc中得到的错误是“test.cpp:18:error:no matching function for call to`sort（\uu gnu\u cxx:：\uu normal\u iterator>>，\uu gnu\u cxx:：：\uu normal\u iterator>>，f（）：：G&）”

---

“

您不能在C++中的另一个函数内创建函数。< /P> 但是，您可以创建本地类函子：

int foo()
{
   class bar
   {
   public:
      int operator()()
      {
         return 42;
      }
   };
   bar b;
   return b();
}

在C++0x中，可以创建lambda表达式：

int foo()
{
   auto bar = []()->int{return 42;};
   return bar();
}

---

正如其他答案所提到的，标准C和C++不允许定义嵌套函数。（有些编译器可能允许它作为扩展，但我不能说我见过它被使用过）

您可以在函数内部声明另一个函数，以便调用它，但该函数的定义必须存在于当前函数之外：

#include <stdlib.h>
#include <stdio.h>

int main( int argc, char* argv[])
{
    int foo(int x);

    /*     
    int bar(int x) {  // this can't be done
        return x;
    }
    */

    int a = 3;

    printf( "%d\n", foo(a));

    return 0;
}


int foo( int x) 
{
    return x+1;
}

#包括
#包括
int main（int argc，char*argv[]）
{
intfoo（intx）；
/*     
int bar（int x）{//这无法完成
返回x；
}
*/
INTA=3；
printf（“%d\n”，foo（a））；
返回0；
}
intfoo（intx）
{
返回x+1；
}

没有显式“链接说明符”的函数声明具有

extern

链接。因此，虽然函数

main（）

中的名称

foo

的声明范围是

main（）

，但它将链接到文件中稍后定义的

foo（）

函数（如果定义了

foo（）

，则链接到另一个文件）

---

或者C++0x中的lambda。

这不值得一个“答案”。“是的。”需要注意的是，函数的作用域是有限的，因此您只能在给定函数内按名称引用它。你仍然可以做一个指向它的函数指针，然后把它扔到别处。是的！你可能是对的，它并不真正值得一个“答案”，但当我们试图解决几个小时，我们寻找任何解决方案。。。我从来没有这样做过，但我正在寻求帮助来解决我的问题。。。谢谢@引人注目的编译器：它可能值得回答，也可能不值得回答，但答案肯定不是简单的“是”。这与回答你的问题有关吗？哈哈。。我刚刚意识到他们没有实现到2010年完成标准的目标。“C++0x”不再是合适的术语。他们将不得不重新修改它“C++1x”或“C++xx”。。。非常遗憾，这花了他们10年多的时间。@Mark：“尽管该标准在2010年之前不会发布，但我们选择保留非正式的名称C++0X，以免引起任何额外的混淆。”——@Mark:还请注意，x可以是十六进制数，允许它跳到F。“可能需要几年时间才能完全支持”或“已经实施，只是等待标准最终确定”，这取决于您使用的编译器。它在VS2010预览版中，正如我们所说，GCC的一个分支正在研究它。Steve我试过了，2010b2确实有这个。是时候编辑我的答案了。太好了！我不知道这个存在，谢谢！问题是我使用MexFunction（）作为主函数，但在其中包含多个线程时遇到了问题。再次感谢@mk:

int foo()
{
   class bar
   {
   public:
      int operator()()
      {
         return 42;
      }
   };
   bar b;
   return b();
}

int foo()
{
   auto bar = []()->int{return 42;};
   return bar();
}

#include <stdlib.h>
#include <stdio.h>

int main( int argc, char* argv[])
{
    int foo(int x);

    /*     
    int bar(int x) {  // this can't be done
        return x;
    }
    */

    int a = 3;

    printf( "%d\n", foo(a));

    return 0;
}


int foo( int x) 
{
    return x+1;
}

void foo()
{
    class local_to_foo 
    { 
         public: static void another_foo() 
         { printf("whatevs"); } 
    };
    local_to_foo::another_foo();
}