C++ 为引用传递的参数指定默认值

我想这样做：

int displayAll(Message *m, string &lastIndex, int &NumPrinted = 0 );

它给我一个错误，从int到int&

我也试过：

int temp =0;

int displayAll(Message *m, string &lastIndex, int &NumPrinted = temp );

class demo {
public:
        void displayAll(int &x, int y = 0 ) {
            int *p;
            if(y)
                p = (int*)y;
            if(p) *p = 10;

        x = 4;
    }
};


int main() {
    int x=0, y=0;
    demo *obj = new demo();
    obj->displayAll((x);
    //obj->temp(x,(int)&y);
    cout << "\n x= " << x << " y " << y;
    return 0;
}

但它仍然给出了以下错误：

error: ISO C++ forbids in-class initialization of non-const static member 'temp'

偶数

静态内部温度给出错误。

错误：ISO C++禁止在非constatic静态成员“临时”
 < p>初始化，除非您声明临时为“代码>静态<代码>：参见StdExcel POST。< /P> < P>对于非常量引用，您不能这样做，除非您声明临时为“代码>静态< /代码>：参见StdExcel POST。
 < P>您提到的第一行代码的问题是，您试图传递对临时变量的引用

class Foo {

    int displayAll(Message *m, bool &moreElements, string &lastIndex, int &NumPrinted = 0 );

};

第二段代码抱怨，因为您试图静态初始化类成员

class Foo {

    int temp =0;

    int displayAll(Message *m, bool &moreElements, string &lastIndex, int &NumPrinted = temp );

};

（我将您的代码放在类声明中，以清楚发生了什么）

不引入静态变量的简单方法是显式函数重载：

class Foo {

    inline int displayAll(Message *m, bool &moreElements, string &lastIndex) {
        int dummy = 0;
        return displayAll(m, moreElements, lastIndex, dummy);
    }
    int displayAll(Message *m, bool &moreElements, string &lastIndex, int &NumPrinted);

};

有一点陈词滥调，但它实现了你想要的。
希望这有帮助

编辑：进一步澄清。问题的核心在于函数必须引用一些它可以修改的内存。如果你传递一个临时变量（临时的，就像C++的术语，而不仅仅是英语术语）（就像你的第一行代码）一样，它是非法的C++，因为你通常在把它作为函数的一个参数之前复制一个临时值：

void bar( int someNum = 0 ); // think of this as creating a temporary rvalue 0
                             // and then copying it into the function for use.

// temporary rvalues arise in expressions like
int v = 5 + 5; // the result of 5 + 5 is stored in a temporary rvalue, and then
               // copied into v (which is an lvalue in this case).

所以我们需要一个“左值”，或者是某个全局变量，或者是一个临时的局部变量（在英语的意义上），正如我在回答中所说的。我正要用一个静态变量编写一个解决方案，但是有一个很大的缺陷——因为静态变量将由类的所有实例共享，所以它将从0开始，然后每次调用该方法时都会不同（因为它会被上一次调用删除）。更糟糕的是，在多线程的情况下，您将从多个处理器读取/写入相同的内存位置，因此该值将完全是垃圾，并且您将破坏处理器内核的缓存，因为每次写入都会使其他每个内核的缓存失效。很难看，请不要这样做P

通过使用我的第一个解决方案，您可以使临时变量非常局部，而不会对其他任何内容产生太大影响。
您提到的第一行代码的问题是，您试图传递对临时变量的引用

class Foo {

    int displayAll(Message *m, bool &moreElements, string &lastIndex, int &NumPrinted = 0 );

};

第二段代码抱怨，因为您试图静态初始化类成员

class Foo {

    int temp =0;

    int displayAll(Message *m, bool &moreElements, string &lastIndex, int &NumPrinted = temp );

};

（我将您的代码放在类声明中，以清楚发生了什么）

不引入静态变量的简单方法是显式函数重载：

class Foo {

    inline int displayAll(Message *m, bool &moreElements, string &lastIndex) {
        int dummy = 0;
        return displayAll(m, moreElements, lastIndex, dummy);
    }
    int displayAll(Message *m, bool &moreElements, string &lastIndex, int &NumPrinted);

};

有一点陈词滥调，但它实现了你想要的。
希望这有帮助

编辑：进一步澄清。问题的核心在于函数必须引用一些它可以修改的内存。如果你传递一个临时变量（临时的，就像C++的术语，而不仅仅是英语术语）（就像你的第一行代码）一样，它是非法的C++，因为你通常在把它作为函数的一个参数之前复制一个临时值：

void bar( int someNum = 0 ); // think of this as creating a temporary rvalue 0
                             // and then copying it into the function for use.

// temporary rvalues arise in expressions like
int v = 5 + 5; // the result of 5 + 5 is stored in a temporary rvalue, and then
               // copied into v (which is an lvalue in this case).

所以我们需要一个“左值”，或者是某个全局变量，或者是一个临时的局部变量（在英语的意义上），正如我在回答中所说的。我正要用一个静态变量编写一个解决方案，但是有一个很大的缺陷——因为静态变量将由类的所有实例共享，所以它将从0开始，然后每次调用该方法时都会不同（因为它会被上一次调用删除）。更糟糕的是，在多线程的情况下，您将从多个处理器读取/写入相同的内存位置，因此该值将完全是垃圾，并且您将破坏处理器内核的缓存，因为每次写入都会使其他每个内核的缓存失效。很难看，请不要这样做P

通过使用我的第一个解决方案，您可以使临时变量非常局部，而不会对其他任何内容产生太大影响。
我也发现了一种有趣的实现方法：

int temp =0;

int displayAll(Message *m, string &lastIndex, int &NumPrinted = temp );

class demo {
public:
        void displayAll(int &x, int y = 0 ) {
            int *p;
            if(y)
                p = (int*)y;
            if(p) *p = 10;

        x = 4;
    }
};


int main() {
    int x=0, y=0;
    demo *obj = new demo();
    obj->displayAll((x);
    //obj->temp(x,(int)&y);
    cout << "\n x= " << x << " y " << y;
    return 0;
}

类演示{
公众：
void displayAll（int&x，int y=0）{
int*p；
如果（y）
p=（int*）y；
如果（p）*p=10；
x=4；
}
};
int main（）{
int x=0，y=0；
demo*obj=新的demo（）；
obj->displayAll（（x）；
//obj->temp（x，（int）和y）；
我也能找到实现这一目标的有趣方法：

int temp =0;

int displayAll(Message *m, string &lastIndex, int &NumPrinted = temp );

class demo {
public:
        void displayAll(int &x, int y = 0 ) {
            int *p;
            if(y)
                p = (int*)y;
            if(p) *p = 10;

        x = 4;
    }
};


int main() {
    int x=0, y=0;
    demo *obj = new demo();
    obj->displayAll((x);
    //obj->temp(x,(int)&y);
    cout << "\n x= " << x << " y " << y;
    return 0;
}

类演示{
公众：
void displayAll（int&x，int y=0）{
int*p；
如果（y）
p=（int*）y；
如果（p）*p=10；
x=4；
}
};
int main（）{
int x=0，y=0；
demo*obj=新的demo（）；
obj->displayAll（（x）；
//obj->temp（x，（int）和y）；
cout什么是
displayPagePrinted
？您显示的代码部分似乎不正确。您显示的任何函数参数中都没有
displayPagePrinted
。错误消息显然与传递参数无关：这似乎与您初始化的类中的静态成员有关使用未使用C++2011.Opps的值！我已更正了收到的错误。什么是
displayPagePrinted
？您没有显示代码的正确部分。您显示的任何函数参数中都没有
displayPagePrinted
。错误消息显然与传递参数无关：this似乎与类中的一个静态成员有关，您可以在不使用C++2011的情况下使用值对其进行初始化。Opps！我已更正了收到的错误。它不必是
静态的
它只需不是临时的。Onl