C++11学习笔记(四)

【POD类型】

POD是 Plain Old Data的缩写，用于说明一个类型的属性。

C++11将POD 划分为2个基本概念的合集——平凡的 和 标准布局的。

“平凡的” 类或结构体 应该符合以下定义

1.平凡的 构造、析构函数；

2.平凡的复制、移动构造函数；

3.平凡的复制赋值运算符、移动赋值运算符；

4.不能包含 虚函数 以及 虚基类

可以通过一些辅助的类模板对以上属性进行判断。

template <typename T> struct std::is_trivial;

下面看一个示例

#include <iostream>
#include <type_traits>
using namespace std;

struct Trivial1 {};
struct Trivial2 {
public:
    int a;
private: 
    int b;
};

struct Trivial3 {
    Trivial1 a;
    Trivial2 b;
};

struct Trivial4 {
    Trivial2 a[23];
};

struct Trivial5 {
    int x;
    static int y; 
};

struct NonTrivial1 {
    NonTrivial1() : z(42) {}
    int z;
};

struct NonTrivial2 {
    NonTrivial2();
    int w;
};
NonTrivial2::NonTrivial2() = default;

struct NonTrivial3 {
    Trivial5 c;
    virtual void f(); 
};

int main() {
    cout << is_trivial<Trivial1>::value << endl;    // 1
    cout << is_trivial<Trivial2>::value << endl;    // 1
    cout << is_trivial<Trivial3>::value << endl;    // 1
    cout << is_trivial<Trivial4>::value << endl;    // 1
    cout << is_trivial<Trivial5>::value << endl;    // 1
    cout << is_trivial<NonTrivial1>::value << endl; // 0
    cout << is_trivial<NonTrivial2>::value << endl; // 0
    cout << is_trivial<NonTrivial3>::value << endl; // 0
    return 0;
}

可以以此结果来对比 “平凡的” 这一特性。

POD 的另一个概念是 标准布局。这一部分 还不太了解，先不写了。

【模板的别名】

在C++中，我们习惯用typedef来定义类的别名，在C++11中，使用using同样可以定义类型的别名。

【基于范围的for循环】

在C++98标准下遍历一个数组

#include <iostream>
using namespace std;

int main() {
    int arr[5] = { 1, 2, 3, 4, 5};
    int * p;
    for (p = arr; p < arr + sizeof(arr)/sizeof(arr[0]); ++p){
        *p *= 2;
    }
    for (p = arr; p < arr + sizeof(arr)/sizeof(arr[0]); ++p){
        cout << *p << '\t';
    }
}

当然，也可以通过类模板来实现

#include <algorithm>
#include <iostream>
using namespace std;

int action1(int & e){ e *= 2; }
int action2(int & e){ cout << e << '\t'; }

int main() {
    int arr[5] = { 1, 2, 3, 4, 5};
    for_each(arr, arr + sizeof(arr)/sizeof(arr[0]), action1);
    for_each(arr, arr + sizeof(arr)/sizeof(arr[0]), action2);
}

最后来看下C++11中的实现

#include <iostream>
using namespace std;

int main() {
    int arr[5] = { 1, 2, 3, 4, 5 };
    for (int & e: arr)
        e *= 2;

    for (int & e: arr)
        cout << e << '\t';
}

如果数组的大小不确定的话，是不能使用基于范围的for循环的

#include <iostream>
using namespace std;

int func(int a[]) {

    for (auto e: a) // 编译失败
        cout << e;
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    func(arr);
}

还有一点值得注意，当循环使用在标准库的容器中时， 如果使用auto来声明迭代的对象，那么，这个对象不会是迭代器对象

#include <vector>
#include <iostream>
using namespace std;

int main() {
    vector<int> v = {1, 2, 3, 4, 5};
    for (auto i = v.begin(); i != v.end(); ++i)
        cout << *i << endl;     // i是迭代器对象

    for (auto e: v)
        cout << e << endl;      // e是解引用后的对象
}