相关疑难解决方法(0)

C++代码是否可以符合C++ 03标准和C++ 11标准,但根据编译的标准,可以做不同的事情吗？

考虑以下:

struct mystruct
{
    int i;
    int j;
};

int main(int argc, char* argv[])
{
    mystruct foo{45, foo.i};   

    std::cout << foo.i << ", " << foo.j << std::endl;

    return 0;
}

请注意foo.i在aggregate-initializer列表中的使用.

g++ 5.2.0 输出

45,45

这是明确定义的行为吗？是foo.i在这个聚集型初始化始终保证指存在创建结构的i元素(和&foo.i将指向内存地址,例如)？

如果我添加一个显式构造函数mystruct:

mystruct(int i, int j) : i(i), j(j) { }

然后我收到以下警告:

main.cpp:15:20: warning: 'foo.a::i' is used uninitialized in this function [-Wuninitialized]
     a foo{45, foo.i};
                ^
main.cpp:19:34: warning: 'foo.a::i' is used uninitialized in this …

我很好奇初始化列表和序列点.我刚才读到初始化程序列表中的评估顺序是从左到右.如果是这样,那么评估点之间肯定会有某种序列点,我错了吗？那么说是以下有效代码？是否有任何导致其未定义的行为？

int i = 0;

struct S {
    S(...) {} 
    operator int() { return i; }
};

int main() {
    i = S{++i, ++i};
}

任何和所有回复都表示赞赏.

当我初始化下面的数组时,所有输出看起来都没问题,除了values[3].出于某种原因,values[3]初始化为values[0]+values[5]输出非常大的数字.我的猜测是,我在尝试分配values[0]+values[5]之前将它们妥善存储在内存中,但是如果有人能够解释那将是很好的.

int main (void)
{

    int values[10] = { 
        [0]=197,[2]=-100,[5]=350,
        [3]=values[0] + values[5],
        [9]= values[5]/10
    };

    int index;

    for (index=0; index<10; index++)
        printf("values[%i] = %i\n", index, values[index]);


    return 0;
}

输出如下:

values[0] = 197
values[1] = 0
values[2] = -100
values[3] = -1217411959
values[4] = 0
values[5] = 350
values[6] = 0
values[7] = 0
values[8] = 0
values[9] = 35

编辑:尚未回答 - 链接的问题是关于普通的r值,初始化列表是一个单独的,如果相关的概念.

这个语句定义得很好,或者在初始化列表中使用前缀增量运算符,对于在列表中出现两次的变量,未定义的行为？

struct T t = { i, ++i };

我对ANSI C最感兴趣,但知道其他版本的C和/或C++是否有所不同也很有用.如果类似以下的类似结构是合法的:

struct T t = { i, i++ };

struct T t = { ++i, ++i };

struct T t = { i++, ++i };

struct T t = { i++, i++ };

以下是完美定义的:

int x = 42, y = x;

即严格等同于:

int x = 42;
int y = x;

编辑:问题不是关于风格(我知道这是错误的......),问题是"理论上的"

在下面的代码中是否需要f1在之前调用f2(反之亦然)或者是否未指定？

int f1();
int f2();

std::initializer_list<int> list { f1(), f2() };

我在C开发了很多年,现在才发现一个程序可以在main()函数之前执行代码.这是一个代码示例

int generateNum(){
    // Some malicious code here...
    return 5;
}

static int someArray[] = {generateNum(),generateNum()}  

int main(){
     // Some code here...
}

该函数generateNum()之前被调用两次main().

我的问题是

1. 谁调用generateNum()？我知道在Windows上它是crtexe()
2. 这种行为是否在不同平台上标准化:Windows/Linux/Android/iOS？
3. 如何获得有关此行为的更多信息？我想在谷歌搜索,但我不知道如何描述它.
4. 我可以在generateNum()中做任何我想做的事吗？我的意思是,我可以调用malloc()吗？那fopen()和fwrite()怎么样？我可以打开套接字并通过UDP发送信息吗？最终我可以滥用这个功能甚至从它调用main():-)

我相信我想做的事情可能是有效的，因为它在两种情况下都用逗号分隔（不是典型的作业），但我不确定并且搜索不会显示有关这两个的任何内容具体情况。

在这两种情况下，我都使用变量作为两个并行数组的索引。

int a[3] = {10, 20, 30};
int b[3] = {20, 40, 60};

情况#1：初始化数组的结构

struct testStruct {
     int t1;
     int t2;
};
int i = 0;
testStruct test = {a[++i], b[i]}

最终行的预期结果：test = {20, 40}

情况#2：将数组中的特定值作为函数参数传递

void testFunc(int t1, int t2) {
    // do stuff
}
int i = 0;
test(a[++i], b[i]);

最终行的预期结果：test(20, 40)

这是有效的代码吗？如果是，它在所有编译器中都有效吗？

结果是我期望的吗？如果是这样，是因为数组还是因为逗号？

谢谢！

具体来说,我说:

struct X { X(int i) { cout << i; } };
int f() { cout << 'f'; return 0; }
int g() { cout << 'g'; return 1; }

struct Z {
    Z() : a(f()), b(g()) {}
    X a, b;
};

int main() { Z z; cout << '\n'; }

我知道成员的构造函数保证按照它们在其中定义的顺序被调用struct,因此0将在之前打印1.但是如何评价他们的论点呢？它保证是:

f0g1

？也许,

fg01

和

gf01

也是有效的输出？

参考该标准是值得赞赏的.

这是示例代码:

X * makeX(int index) { return new X(index); }
struct Tmp {
    mutable int count;
    Tmp() : count(0) {}
    const X ** getX() const { 
        static const X* x[] = { makeX(count++), makeX(count++) };
        return x; 
    }
};

这将在静态数组构造中报告CLang build 500上的Undefined Behavior.为了简化这篇文章,计数不是静态的,但它不会改变任何东西.我收到的错误如下:

test.cpp:8:44:警告:对'count'的多次无序修改[-Wunsequenced]