小编son*_*yao的帖子

我知道const,创造后无法改变.但是我想知道是否有办法声明一个你只设置一次的变量,然后就不能覆盖了.在我的代码中,我想避免bool变量nFirst,一旦设置为nIdx,就不能设置为新的值nIdx.

我的代码:

    int nFirst = 0;
    int nIdx = 0;
    bool bFound = false;
    BOOST_FOREACH(Foo* pFoo, aArray)
    {
        if (pFoo!= NULL)
        {
            pFoo->DoSmth();
            if (!bFound)
            {
                nFirst= nIdx;
                bFound = true;
            }
        }
        nIdx++;
    }

据已知特征的C++,一个常量引用延伸从函数返回的临时对象的生命时间,但是它可以接受使用恒定的参考到临时对象的成员从函数返回？

例:

#include <string>

std::pair<std::string, int> getPair(int n)
{
    return {std::to_string(n), n};
}

int main(int, char*[])
{
    const int x = 123456;
    const auto& str = getPair(x).first;
    printf("%d = %s\n", x, str.c_str());    
    return 0;
}

输出:

123456 = 123456

我正在用我最新的gcc g ++编译器编译一个过时的项目,(版本> 6)

有一个CodeWriter带ostream引用变量的类.

class CodeWriter
{
  //private:
protected:
  ostream &m_stream;
public:
  CodeWriter(ostream &stream):m_stream(stream){}
  ~CodeWriter(){
    if(m_stream != NULL){
      m_stream.flush();
    }
  }
};

这个类非常大,所以我只包含了相关的变量和函数.

正如您所看到的,析构函数似乎是在比较引用NULL.当我用旧的gnu工具链使用它时,这个项目编译得很好.

但现在它抛出一个错误,说没有匹配operator !=比较ostream和long int.

任何人都可以解释改变背后的理由,以及我如何解决这个问题？

如果需要,我很乐意提供更多信息/包括全班.

这两个功能之间有什么显着差异吗？

struct Object {
    Object(int i) : i{i}
    {
    }

    int i;
};

Object f() { return {1}; }
Object g() { return Object{1}; }

'值语义'是什么意思,'隐式指针语义'是什么意思？

继续在Swift中玩游戏并尝试从C世界转换某些内容并且一直试图尝试各种语法.我有一些我想要初始化为结构数组的固定数据.这是我在C中如何做到这一点,但我无法在Swift中弄清楚,所以不要再猜测我会问那些了解更多的人.这是我的C代码.

#include <stdio.h>

typedef struct my_data {
  const char *company;
  const char *city;
  const char *state;
  float latitude;
  float longitude;  
} my_data;

int main() {

    my_data data[2]={
        { "Joes Crab Shack", "Miami", "FL", 30.316599, -119.050254},
        { "Jims Crab Shack", "Los Angeles", "CA", 35.316599, -112.050254}
    };
}

在Swift中我可以创建一个类似的结构...

struct my_data {
    var company = String();
    var city = String();
    var state = String();
    var latitude:Float;
    var longitude:Float;
}

现在我陷入了如何声明和初始化固定数据,就像我在C中所做的那样.猜测它很简单并且语法正确让我感到困惑.我想将初始化样式保持为与C类似的格式,因为我可以轻松地从文件中提取和格式化这些数据.

考虑以下代码:

#include <vector>

struct A {
  static constexpr int kDefaultValue = -1;
  std::vector<int> v;
  A(int n): v(n, A::kDefaultValue) {}
};

int main() {
  A(10);
  return 0;
}

它无法链接(llvm clang,gcc 4.9,两者都在OS X上):

Undefined symbols for architecture x86_64:
  "A::kDefaultValue", referenced from:
      A::(int) in main.cpp.o
ld: symbol(s) not found for architecture x86_64

问题是它有什么问题？它可以通过static_cast-ing A::kDefaultValue来修复int.或者搬出kDefaultValue去A.两个案件似乎都很难看.这是另一种使它链接的方式吗？

考虑以下代码:

struct X{
    explicit X(){}
    explicit X(const X&){}
};

void foo(X a = X()){}

int main(){}

使用C++ 14标准,GCC 7.1和clang 4.0都拒绝代码,这正是我所期望的.

但是,使用C++ 17(-std=c++1z),它们都接受代码.什么规则变了？

对于两个编译器都表现出同样的行为,我怀疑这是一个bug.但据我所知,最新的草案仍然说,默认参数使用复制初始化 ¹的语义.同样,我们知道explicit构造函数只允许直接初始化 ².

¹:dcl.fct.default/5 ; ²:class.conv.ctor/2

令人惊讶的是，无论在函数名之前使用什么符号，以下代码在 gcc 和 clang 中都能很好地编译：*，&或者什么都不用。标准是否允许其中任何一个？存储函数指针的首选方法是什么？

#include <stdio.h>

typedef int foo(int a);

template <typename X>
int g(int y) {
    return y * sizeof(X);
}

int main() {

    foo* xxx;

    // 1. what is correct according to standard?
    // 2. why they all work?
    xxx = *g<float>;
    xxx = &g<float>;
    xxx = g<float>;

    printf("ok %d\n", xxx(5));
}

考虑：

class A
{
protected:
    A(int) {}
    void f(int) {}

public:
    A() {}
};

class B : public A
{
public:
    using A::A;
    using A::f;
};

int main()
{
    B().f(1); // ok
    B(1); // error: 'A::A(int)' is protected within this context
}

为什么不能创建继承的protected构造函数public，而继承的protected成员函数可以？