标签: function-declaration

比方说,我有一系列具有相同原型的功能

int func1(int a, int b) {
  // ...
}
int func2(int a, int b) {
  // ...
}
// ...

现在,我想简化他们的定义和声明.当然我可以使用这样的宏:

#define SP_FUNC(name) int name(int a, int b)

但是我想把它保存在C中,所以我尝试使用存储说明符typedef:

typedef int SpFunc(int a, int b);

这似乎适用于声明:

SpFunc func1; // compiles

但不是定义:

SpFunc func1 {
  // ...
}

这给了我以下错误:

error: expected '=', ',', ';', 'asm' or '__attribute__' before '{' token

有没有办法正确地做到这一点还是不可能？根据我对C的理解,这应该有效,但事实并非如此.为什么？

注意,gcc理解我要做的事情,因为,如果我写的话

SpFunc func1 = { /* ... */ }

它告诉我

error: function 'func1' is initialized like a …

下面给出了某些函数声明的JavaScript代码片段吗？如果不是,有人可以概述一下它们是什么吗？

some_func = function(value) {
    // some code here
}

和

show:function(value){
   // some code here
}

我知道函数定义中的最小参数数量为零,但函数定义中的最大参数数量是多少？我只是为了知识和好奇而问这个问题,而不是我要写一个真正的功能.

在这段代码中,为什么f()被声明为"double&f(..."？它是什么意思,它是如何工作的？我甚至不知道谷歌要找到我的问题的答案.请帮忙.

double a = 1, b = 2;
double & f (double & d) {
    d = 4;
    return b;
}

我知道&符号表示变量或函数的地址,但我不明白为什么在声明函数时编写它是有意义的.

我已经看到了将函数指针作为参数的函数定义：

double fin_diff(double f(double), double x, double h  = 0.01) {
  return (f(x+h)-f(x)) / h;
}

我习惯用星号来查看此定义，即：

double fin_diff(double (*f)(double), double x, double h  = 0.01);

您知道为什么第一个定义也有效吗？

在阅读这个问题的一些答案时,我开始想知道为什么编译器在第一次遇到函数时确实需要知道它.在解析收集在其中声明的所有符号的编译单元时添加额外的通道是不是很简单,这样它们的声明和使用顺序就不再重要了？

有人可能会争辩说,在使用它们之前声明函数肯定是好的风格,但我想知道,为什么在C++中这是强制性的还有其他原因？

编辑 - 举例说明:假设您必须在头文件中内联定义的函数.这两个函数相互调用(可能是递归树遍历,其中树的奇数层和偶数层的处理方式不同).解决这个问题的唯一方法是在另一个函数之前声明其中一个函数.

一个更常见的例子(虽然有类,而不是函数)是带有private构造函数和工厂的类的情况.工厂需要知道类以便创建它的实例,并且类需要知道工厂的friend声明.

如果要求来自以前的日子,为什么它在某些时候没有被删除？它不会破坏现有的代码,不是吗？

1. 令我惊讶的是,我发现c ++对象的名称可以与类名相同.有人可以向我解释原因吗？
2. 当我宣布类的对象a为a a1(),它不会引发错误,但不会调用构造函数.为什么会这样？

我的代码:

#include<iostream>
using namespace std;

class a 
{
    public:
    a() 
    {
        cout << "in a\n";
    }
};

int main()
{
    a a1();
    a a;
}

考虑：

#include <iostream>
using namespace std;

void Change(int arr[3]) {
    for (int i = 0; i < 3; i++) {
        arr[i] = 1;
    }
}

int Test() {
    int arr[3] = { 0, 0, 0 };

    for (int i = 0; i < 3; i++) {
        cout << arr[i] << endl;
    }

    Change(arr);

    for (int i = 0; i < 3; i++) {
        cout << arr[i] << endl;
    }

    return 0;
}

由于数组默认作为指向其第一个元素的指针传递并且不会被复制，因此在函数中更改数组元素的值实际上会导致在函数调用者中更改数组该元素的值，这就是为什么以上代码输出

#include <iostream>
using namespace std;

void Change(int …

我现在正在我的大学学习C ++和OOP的基础知识。我不确定100％分配函数给函数指针时如何工作。我遇到了以下代码：

void mystery7(int a, const double b) { cout << "mystery7" << endl; }
const int mystery8(int a, double b) { cout << "mystery8" << endl; }

int main() {
    void(*p1)(int, double) = mystery7;            /* No error! */
    void(*p2)(int, const double) = mystery7;
    const int(*p3)(int, double) = mystery8;
    const int(*p4)(const int, double) = mystery8; /* No error! */
}

从我的理解来看，p2和p3分配很好，因为函数参数类型匹配并且const-ness是正确的。但是，为什么p1和p4分配失败？将const double / int与非const double / int匹配是否不合法？

如果声明的函数具有noexceptspecificator( ,noexcept,noexcept(true),noexcept(false)或任何其他noexcept(expr)计算结果为true或false),但它在另一个地方定义的,做我需要指定noexcept再次定义符,或仅在其向前声明？