小编R S*_*ahu的帖子

在看到本地引用const可能会延长临时的生命之后,我遇到了有条件地将本地reference-to-const绑定到函数参数或函数调用的临时结果的需要,即:

class Gizmo
{
    // Rule of Five members implemented
};

Gizmo Frobnicate(const Gizmo& arg);

void ProcessGizmo(const Gizmo& arg, bool frobnicate)
{
    const Foo& local = frobnicate ? Frobnicate(arg) : arg;
    // Perform some work on local
}

一个实际的例子:boolean指定是否压缩缓冲区,并且您希望编写以local任一方式操作的统一代码.

上面的例子,但是,在调用小玩意儿的拷贝构造函数arg时frobnicate是false.我设法通过更改Frobnicate(arg)为避免复制构造函数的调用static_cast<const Gizmo&>(Frobnicate(arg)).

我的问题变成:三元运算符如何与关于将本地引用到const绑定到临时的规则进行交互？我的解决方案是否合法且表现良好？

我期望在下面的程序中使用gcc看到"charmer数组的初始化字符串太长"警告.

程序:

int main()
{
   char str1[4]="1234";
   char str2[3]="1234";

   (void)str1; // Remove unused variable warning.
   (void)str2; // Remove unused variable warning.
   return 0;
}

但是,我只收到警告str2.

以来

char str1[4]="1234";

相当于

char str1[4]= {'1', '2', '3', '4', '\0'};

我们不应该也得到同样的警告str1吗？

这是gcc的缺陷吗？

编译命令:

gcc -Wall -std = c99 soc.c -o soc

gcc 版本是4.8.4.

更新

刚才了解到

char str1[4]="1234";

不等于

char str1[4]= {'1', '2', '3', '4', '\0'};

更新2

char str1[4]="1234";

在C++ 11中是不正确的(第8.5.2/2节).我不认为C99和C++ 11会以不同的方式对待它们.

在下面的代码片段中，我希望能够A::foo从doWork.

但是，因为foo(const和非const)有两个重载，编译器无法解析我在调用doWork. 有没有办法告诉编译器我的意思是哪个。

我无法改变struct A。

我可以在 doWork 的签名或 doWork 的调用中做一些事情来总是选择说 const 的。

我知道的一种解决方案是将函数指针类型作为参数doWork而不是模板（像这样） void doWork(void (A::*fun)(void) const){ 但这有点难看，我希望找到一个基于模板的解决方案（如果存在的话）

struct A{
    void foo() const {
    }
    void foo(){
    }
    void bar(){
    }
    void bar() const {
    }
};

template<typename F>
void doWork(F fun){
    const A a;
    (a.*fun)();
}

int main()
{
    doWork(&A::foo); //error: no matching function for call to ‘doWork()’
    doWork(&A::bar); // error: no matching …

术语"对象表达"首先出现在C++ 11草案标准中:

3.4.5类成员访问 [basic.lookup.classref]

1. 在类成员访问表达式(5.2.5)中,如果是.或 - > token后面紧跟一个标识符后跟一个<,必须查找标识符以确定<是模板参数列表(14.2)的开头还是小于运算符.首先在对象表达式的类中查找标识符.如果未找到标识符,则在整个postfix-expression的上下文中查找它,并命名一个类模板.

我可以在Web上找到F#的"对象表达"的定义,但不能找到C++的定义.

这是一个普遍理解的术语吗？这是什么意思？

使用std :: setbase格式化数字以将int的数字最小值传递给std :: stoi会引发std :: out_of_range异常,但我不明白为什么.如果有人能帮助我更好地理解异常背后的推理,我将非常感激.

代码片段:

#include <iomanip>
#include <iostream>
#include <limits>
#include <sstream>

template <typename T>
std::string toString(const T x, const int base)
{
    std::stringstream ss;
    ss << std::setbase(base) << x;
    return ss.str();
}   

int main(void)
{
    const int x = std::numeric_limits<int>::min();
    std::size_t index = 0;
    const auto base = 16;
    const auto s = toString(x, base);
    std::cout << "base-10: " << x << std::endl
              << "base-" << base << ": " << s << std::endl;
    std::cout …

我在 Visual Studio 中编写了一个计算器程序。但我还需要它与 DEVC++ 一起运行。但我的代码不能在 gcc 编译器上运行。这是代码的一小部分不起作用。

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <stdbool.h>

int main(){

    long double var1 = 0, var2= 0, memory, result;
    char wordInput[50] = { 0 };
    char *endPtr1, *endPtr2;

    printf("Enter an input: ";
    scanf("%[^\n]%*c", wordInput);

    var1 = strtold(wordInput, &endPtr1);
    printf("%.4f", var1);

}

这是我获取输入并将其转换为 double 并分配给 var1 的代码块。当我用 Visual Studio 编译它时，它可以工作（它打印输入的数字），但使用 devc++ 则不行（它打印 0.0000）。我可以做什么来修复它？

这是我想要使用的代码的一个简短示例:

template <class T>
class B
{
public :
    bool func1(const T& t)
    {
        // do something
    }
};


class A
{
    B<int*> b;
public:
    void func2(const int* a)
    {
        b.func1(a);
    }
};

我收到这个错误:

错误C2664:'B :: func1':无法将参数1从'const int*'转换为'int*const&'

是一种解决这个问题的方法,而无需更改函数声明和不使用const_cast？

编辑:

问题背后的一些信息

1. B 实际上是我写的容器类(比如列表)

2. A 是使用该列表的类

3. func1 是一个需要查找元素是否在列表中的函数

4. func2 是一个接收要从列表中删除的元素的函数

尽管我花费了不合理的时间,但我仍然无法解决这个问题.我想要一个列表<list <int*>>,但它不起作用.这是我的代码:

int main(int argc, const char * argv[]) {
   int a=2;
   int b=3;

   list<list<int*>> test;

   list< list<int*> >::iterator it;
   it = test.begin();

   it->push_back(&a);
   it->push_back(&b);

   b=4; //should modify the content of "test"

   for(list <int*>::iterator it2 = it->begin(); it2 != it->end(); it2++) {
      cout << *it2 << endl;
   }
}

使用xCode,它编译但我有一个"线程1:EXC_BAD_ACCESS"错误.希望你能开导我!

谢谢 !

我在cppreference.com上查找一个临时的生命周期,我发现C++ 14发生了一些变化:

每当引用绑定到临时或临时的基础子对象时,临时的生命周期将扩展为与引用的生命周期匹配,但以下情况除外:

...

绑定到构造函数初始值设定项列表中的引用成员的临时绑定仅在构造函数退出之前持续存在,而不是只要该对象存在.(注意:从DR 1696开始这样的初始化是不正确的)(直到C++ 14)

我检查了标准,真的没有这样的说法.($ 12.2/5临时物品[class.temporary])

这是否意味着从C++ 14开始,临时绑定到引用成员的生命周期将扩展到对象的生命周期？

我尝试了以下代码与GCC和CLANG似乎都没有,临时将被构造函数结束时销毁.

#include <iostream>

struct X {
    ~X() { std::cout << "X dtor\n"; }
};
struct Y {
    Y() : x_(X()) { std::cout << "Y ctor\n"; }
    const X& x_;
    ~Y() { std::cout << "Y dtor\n"; }
};
int main()
{
    Y y;
    std::cout << "Hello, world!\n";
}

结果:

Y ctor
X dtor
Hello, world!
Y dtor

我误解了吗？

你可以在代码中看到，enum CardSuit是不是static

我不明白Deck构造函数如何直接MAX_SUITS在以下代码行中访问：

for (int suit = 0; suit < Card::MAX_SUITS; ++suit)

Card类Deck访问MAX_SUITS是否不需要类对象？

就像是：

Card card1;
for (int suit = 0; suit < card1::MAX_SUITS; ++suit)

如果我int x;在Class Card中声明并在class的Card::x内部定义中说Deck，那么我会得到一条错误消息：“非静态成员的不当使用”。我原本也希望使用时会遇到相同的错误Card::MAX_SUITS，但事实并非如此，它工作正常。

这是程序的相关部分：

class Card
{
public:
    enum CardSuit
    {
        SUIT_CLUB,
        SUIT_DIAMOND,
        SUIT_HEART,
        SUIT_SPADE,
        MAX_SUITS
    };

    enum CardRank
    {
        RANK_2,
        RANK_3,
        RANK_4,
        RANK_5,
        RANK_6,
        RANK_7,
        RANK_8,
        RANK_9,
        RANK_10,
        RANK_JACK,
        RANK_QUEEN,
        RANK_KING,
        RANK_ACE,
        MAX_RANKS
    }; …