C++11奇怪的语法

1. istream_iterator

简而言之，istream_iterator像操作容器一样操作istream。例如下面代码，从std::cin构造std::istream_iteream<int>类型迭代器，可以用于从cin顺序读取int数值。该迭代器又被用于初始化int型vector。

#include <iostream>
#include <iterator>
#include <vector>
#include <algorithm>
int main()
{
    std::istream_iterator<int> in_iter(std::cin);
    std::istream_iterator<int> eof;

    std::vector<int> vec(in_iter, eof);

    for_each(vec.cbegin(),
            vec.cend(),
            [] (const int i) {
                std::cout << i << std::endl;
            });

    return 0;
}

 编译并运行这个例子：

$ g++ --std=c++11 -Wall -o test test.cpp
$ ./test
1
2
3
4
^D
1
2
3
4

2. 元素个数为0的数组

// mingw32 G++4.9.2 with --std=c++11
#include <iostream>
int main()
{
    int q[0];

    // std::cout << q[0] << std::endl;
    for (auto b: q) {
        std::cout << b << std::endl;
    }
    return 0;
}

在C++11中，不能通过std::begin(q), std::end(q)获得元素为0数组的iterator：

#include <iostream>

int main()
{
    int p[0];

    auto b = std::begin(p); // error
    return 0;
}

3. new[0]

C++的new语法用来在运行时动态申请内存，

char *p = new char;

而new[]语法则用来动态申请一片连续的内存区域：

int n = 10;
char *pa = new char[n];

上例中，当n等于0时，会发生什么呢？

#include <iostream>
int main()
{
    int n = 0;
    int *p = new int[n];

    // std::cout << *p << std::endl;  // undefined

    for (int *q = p; q != p + n; ++q) {
        std::cout << q << std::endl;
    }
    return 0;
}

上例是完全可以执行的，也就是p = new [0]返回了一个合法的指针，该指针可以向其他指针一样做比较，但却不可以解引用，如上例中注释掉那一行，毕竟数组是空的。

4. 没有返回类型的Conversion Operator

Converion Operator是一种特殊的类成员函数，其语法如下：

operator type() {}

其中type是转换的目标类型。

虽然没有返回类型，函数体中又必须返回type类型value：

#include <iostream>

class SmallInt {
public:
    SmallInt(int i) : _i(i){}
    operator int() {return _i;}  // Convertion Operator
private:
    int _i;
};

int main()
{
    SmallInt si(3);
    int ret = si + 4;
    std::cout << ret << std::endl;
    return 0;
}

 5. Reference Collapsing Rule

通过typedef等语法创建引用的引用，适用引用折叠原则：

T & & =>T&

T&& & => T&

T& && => T&

T&& && => T&&

也就是，除去右值引用的右值引用一种情况，全部折叠成普通引用；而右值引用的右值引用则折叠成右值引用