C++11代码示例

C++11代码示例：

/**
-* c++11demo.cpp
-* zsj, 20130415
-* 测试环境：GCC4.8, VS2010
-*/

#include <ctime>
#include <cstring>
#include <cstdlib>
#include <limits>
#include <iostream>
#include <sstream> /* for stringstream */
#include <string>
#include <vector>
#include <map>
#include <list>
#include <algorithm>
#include <functional>
#include <unordered_map>

#include "hash_map"

#include "boost/lexical_cast.hpp"

using namespace std;

typedef enum SexType_E
{
    ESEX_MALE = 0,
    ESEX_FEMAIL = 1,
    ESEX_UNKNOWM = 2,
} SexType;

typedef struct Record_T
{
    char name[16];
} Record;

/*
 * unions
 */
struct point
{
    point() {}
    point(int x, int y): x_(x), y_(y) {}
    int x_, y_;
};
union CPP11_U
{
    int z;
    double w;
    // 合法的 C++11 语句
    point p; // point 有一 non-trivial 建构式，之前的C++标准视作非法
    char *ptr;
    int seq[4];
    vector<int> vi; // not a POD member
};

/*
 * 类型自动推导
 */
template<class T, class U>
void TUmultiply (const vector<T> &vt,
                 const vector<U> &vu)
{
    // ...
    int size = (vt.size() > vu.size()) ? vt.size() : vu.size();

    for(int i = 0; i < size; i++)
        auto tmp = vt[i] * vu[i];
    // ...
}

template< typename LHS, typename RHS>
auto AddingFunc(const LHS &lhs, const RHS &rhs) -> decltype(lhs+rhs)
{
    return lhs + rhs;
}

/*
 * 常量表达式
 */
constexpr int GetFive()
{
    return 5;
}

enum Flags { good=0, fail=1, bad=2, eof=4 };

constexpr int operator| (Flags f1, Flags f2)
{
    return Flags(int(f1) | int(f2));
}

void f(Flags x)
{
    switch (x)
    {
    case bad: /* … */
        break;
    case eof: /* … */
        break;
    case bad|eof: /* … */
        break;
    default: /* … */
        break;
    }
}

void ff(Flags f3)
{
    // 错误：因为f3不是常量，所以无法在编译时期计算这个表达式的结果值
    // constexpr int x2 = bad|f3;
    int x3 = bad|f3; // ok，可以在运行时计算
}

struct Point
{
    int x,y;
    constexpr Point(int xx, int yy) : x(xx), y(yy) {}
};

/*
 * decltype grammer
 */
void DcltpF(const vector<int>& va, vector<float>& vb)
{
    // 推断表达式a[0]*b[0]的数据类型，并将其定义为Temp类型
    typedef decltype(va[0]*vb[0]) Tmp;
    // 使用Tmp作为数据类型声明变量，创建对象
    for (int i = 0; i < vb.size(); ++i)
    {
        Tmp *p = new Tmp(va[i]*vb[i]);
        // …
    }
}

class X
{
    X& operator=(const X&) = delete; // 禁用类的赋值操作符
    X(const X&) = delete; // 禁用类的复制构造函数
};

class Y
{
    // 使用默认的赋值操作符和复制构造函数
    Y& operator=(const Y&) = default; // 使用默认的赋值操作
    Y(const Y&) = default; // 使用默认的复制构造函数
};

struct Z
{
    Z(long long); // 可以通过long long初始化
    Z(long) = delete; // 但是不能将long long转换为long进行初始化
};

class BigType
{
public:
    BigType Get() { return *this; }

public:
    int attr[1024];
    // ...
};

BigType BigTypeFunc()
{
    return BigType();
}

BigType&& BigTypeFuncRR()
{
    return BigType();
}

BigType& SetBigTypeValueRR(BigType&& bigV)
{
    BigType a = bigV;
    BigType &&rra = a.Get();
    rra.attr[0] = 0;
    return bigV;
}

/*
 * 在缺省情况下，一个类拥有 6 个默认的操作函数：
 * 缺省构造函数 (constructor)           TC( void );
 * 拷贝构造函数 (copy constructor)      TC( const TC &);
 * 缺省析构函数 (destructor)            ~TC( void );
 * 赋值运算符函数 (copy assignment)     TC & operator= (TC &);
 * 取址运算符函数 (address-of)          TC * operator& (void);
 * 常量取址运算符函数 (address-of)      const TC * operator& (void) const;
 * c++11标准新增：
 * 移动构造函数 (move constructor)      TC (TC &&)
 * 移动赋值操作符函数 (move assignment) TC & operator= (TC &&)
 */
/* 如果显式地指明（ 声明、定义、=default 或者 =delete ）了移动、复制或者析构函数
 * 的行为，将不会产生默认的移动操作（移动赋值操作符和移动构造函数）。
 * 同时，未声明的复制操作（复制赋值操作符和复制构造函数）会被默认生成，
 * 但是，这是是应该尽量避免的，不要依赖于编译器的这种行为。
 * 如果声明了上述 5 个默认函数中的任何一个，则强烈建议显式地声明所有这 5 个默认函数。
 */
template<class T>
class Handle
{
    T* p;
public:
    Handle(T* pp) : p {pp} // 用户定义构造函数： 没有隐式的复制和移动操作
    {}

    ~Handle()
    {
        delete p;
    }

    Handle(Handle&& h) : p {h.p} // transfer ownership
    { h.p = nullptr; };
    Handle& operator=(Handle&& h) // 传递所有权
    {
        delete p;
        p = h.p;
        h.p = nullptr;
    }

    Handle(const Handle&) = delete; // 禁用复制
    Handle& operator=(const Handle&) = delete;
    // ...
};

/*
 * 委托构造函数（Delegating constructors）
 */
class BadX_Exception
{
public:
    BadX_Exception(int errID)
    {
        // 输出构造函数被调用信息
        std::cout << "BadX_Exception is called" << std::endl;
        error_ID = errID;
    }

    int GetErrorID()
    {
        return error_ID;
    }
private:
    // 错误码
    int error_ID;
};

/*
 * 委托构造函数： Delegating constructors
 */
class DlgtX
{
    int a;
public:
    DlgtX(int x)
    {
        if (0<=x && x<=numeric_limits<int>::max()) a=x;
        else throw BadX_Exception(x);
    }
    // 构造函数X()调用构造函数X(int x)
    DlgtX() :DlgtX {0} { }
    // 构造函数X(string s)调用构造函数X(int x)
    DlgtX(string s) :DlgtX {boost::lexical_cast<int>(s)} { }
    //
};

/*
 * noexcept: 阻止异常的传播与扩散
 */
extern "C" double sqrt(double) noexcept; // 永远不会抛出异常

// 在这里，我不准备处理内存耗尽的异常，所以我只是简单地将函数声明为noexcept
vector<double> my_computation(const vector<double>& v) noexcept
{
    vector<double> res(v.size()); // 可能会抛出异常
    for(int i; i<v.size(); ++i)
        res[i] = sqrt(v[i]);
    return res;
}

/*
 * 外部模板声明
 */
// file A.cpp
// extern template class MyVector<int>; // 消除后续的隐式实例化
// file B.cpp 使MyVector类对客户端（clients）可用（例如，共享库）
// template class MyVector<int>;

/*
 * 序列化 for 循环
 */
void SeqFor(vector<int> &v)
{
    for (auto x : v) cout << x << 'n';
    for (auto &x : v) ++x; // 使用引用，方便我们修改容器中的数据
    for (const auto x :
{
    1,2,3,5,8,13,21,34
})
    cout << x << 'n';
}

/*
 * 初始化列表
 */
// 对变量进行初始化的机制实际上是通过一个可以接受参数类型
// 为std::initializer_list的函数（通常为构造函数）来实现的。
// 例如：
void Init_F(initializer_list<int> args)
{
    for (auto p=args.begin(); p!=args.end(); ++p)
        cout << *p << "n";
}

/*
 * Lambda表达式是一种描述函数对象的机制，
 * 它的主要应用是描述某些具有简单行为的函数
 */
// 一个Lambda表达式可以存取在它被调用的作用域内的局部变量
void Lambda_F(vector<Record>& v)
{
    vector<int> indices(v.size());
    int count = 0;

    generate(indices.begin(), indices.end(),
             [&count]()
    {
        return count++;
    });

    // sort indices in the order determined by the name field of the records:
    std::sort(indices.begin(), indices.end(), [&](int a, int b)
    {
        return v[a].name<v[b].name;
    });
    // …
}

/*
 * 返回值类型后置
 */
template<class T, class U>
auto mul(T x, U y) -> decltype(x*y)
{
    return x*y;
}

///////////////////////////////////////////////////////////////////////////

/*
-* string to time_t
-* 时间格式 2009-3-24 0:00:00 或 2009-3-24
-*/
time_t StringTimedTick(const std::string &strTime)
{
    time_t tickTime;
    char *ptrBegin = (char*) strTime.c_str();
    char *ptr = strstr(ptrBegin, "-");
    if(ptr == nullptr)
    {
        std::cout << "strTime[" << strTime << "%s] err" << std::endl;
        return 0;
    }
    int year = atoi(ptrBegin);
    int month = atoi(ptr + 1);
    ptr = strstr(ptr + 1,"-");
    if(ptr == nullptr)
    {
        std::cout << "strTime[" << strTime << "] err" << std::endl;
        return 0;
    }
    int day = atoi(ptr + 1);
    int hour = 0;
    int minute = 0;
    int second = 0;
    ptr = strstr(ptr + 1, " ");

    //为了兼容有些没精确到时分秒的
    if(ptr != nullptr)
    {
        hour = atoi(ptr + 1);
        ptr = strstr(ptr + 1, ":");
        if(ptr != NULL)
        {
            minute = atoi(ptr + 1);
            ptr = strstr(ptr + 1, ":");
            if(ptr != nullptr)
            {
                second = atoi(ptr + 1);
            }
        }
    }

    struct tm dateTime;
    memset((void*)&dateTime, 0, sizeof(dateTime));
    dateTime.tm_sec = second;
    dateTime.tm_min = minute;
    dateTime.tm_hour = hour;
    dateTime.tm_mday = day;
    dateTime.tm_mon = month - 1;
    dateTime.tm_year = year - 1900;
    tickTime = mktime(&dateTime);
    return tickTime;
}

/*
-* time_t to string
-*/
std::string & TickTimedString(time_t tickTime, int offSec, std::string &strTime)
{
    struct tm *p;
    std::stringstream out;

    tickTime += offSec;
    p = localtime(&tickTime);

    p->tm_year = p->tm_year + 1900;
    p->tm_mon = p->tm_mon + 1;

    out << p->tm_year << '-' << p->tm_mon << '-' << p->tm_mday
        << ' ' << p->tm_hour << ':' << p->tm_min << ':' << p->tm_sec;
    strTime = out.str();
    //strm << std::setw(4) 
    //     << std::setw(2) << std::setfill('0') 
    //     << std::setw(2) << std::setfill('0') 
    //     << '_' << std::setw(2) << std::setfill('0') 
    //     << ':' << std::setw(2) << std::setfill('0') 
    //     << ':' << std::setw(2) << std::setfill('0') 
    //     << std::hex << std::uppercase << std::setw(4) << std::setfill('0') << dateTime.millitm;
    //strm >> strTime;
    return strTime;
}

/*
 * 测试 map, pair
 */
typedef struct BabyInfo_T
{
    time_t birthTime;
    SexType sex;
    float   weight; // gram
    float   heighth; // millimeter
    std::string nickName;

    bool operator < (const struct BabyInfo_T &v) const
    {
        return birthTime < v.birthTime;
    }
} BabyInfo;

typedef struct Mother_T
{
    int age;
    std::string name;
    std::string address;
} Mother;

int STL_Map_Test(int argc, char **argv)
{
    std::map<BabyInfo, Mother> bornMap;
    std::pair<BabyInfo, Mother> element;

    BabyInfo babyInfo;
    babyInfo.birthTime = StringTimedTick("2013-3-14 2:34:56");
    babyInfo.sex = ESEX_FEMAIL;

    Mother mother;
    mother.age = 25;
    mother.name = "susan";

    element.first = babyInfo;
    element.second = mother;

    bornMap.insert(element);

    babyInfo.birthTime = StringTimedTick("2013-3-15 13:45:6");
    babyInfo.weight = 3456;
    mother.age = 26;
    mother.name = "jone";
    mother.address = "BeiJing";
    element.first = babyInfo;
    element.second = mother;

    bornMap.insert(element);

    std::string strTime;
    for(std::map<BabyInfo, Mother>::iterator iter = bornMap.begin();
            iter != bornMap.end(); iter++)
    {
        std::cout << TickTimedString(iter->first.birthTime, 0, strTime)
                  << std::endl;
    }

    return 0;
}

/*
 * Hash test
 */

class Usr_Key
{
public:
    Usr_Key(int n, const string &s) : id(n), name(s) { }

public:
    int id;
    std::string name;
};

class Usr_Type
{
public:
    Usr_Type()
    {
        name = model = description = "";
    };
    Usr_Type(const string &s, const string &m, const string &d)
        : name(s), model(m), description(d) { }

    const string &GetName() const
    {
        return name;
    }
    const string &GetModel() const
    {
        return model;
    }
    const string &GetDescription() const
    {
        return description;
    }

private:
    string name, model, description;
};

/*
 * deine an unordered map with Usr_Key instances as keys
 * and Usr_Type instances as values
 */
// The HASH object can either be a class(which implementing a
// function call operator that takes an object of type KEY
// as argument and returns a unique value of type size_t based
// on it), or a pointer to a function.
class Usr_HashKey
{
public:
    size_t operator() (const Usr_Key &x) const
    {
        hash<string> z;
        return z(x.name) * 100 + x.id;
    }
};
// if the class we want to use as key overloads the operator==,
// then we do not need to provide an argument for the EQUAL_TO
// template argument
class Usr_HashPredicate
{
public:
    bool operator() (const Usr_Key &a, const Usr_Key &b) const
    {
        return (a.name == b.name) && (a.id == b.id);
    }
};

ostream &operator<< (ostream &os, const Usr_Key &a)
{
    return os << a.id << "(" << a.name << ") ";
}

ostream &operator<< (ostream &os, const Usr_Type &a)
{
    return os << "Name: " << a.GetName() << "; Model: " << a.GetModel()
           << "; Description: " << a.GetDescription();
}
//template < class Key, // unordered_map::key_type
// class T, // unordered_map::mapped_type
// class Hash = hash<Key>, // unordered_map::hasher
// class Pred = equal_to<Key>, // unordered_map::key_equal
// class Alloc = allocator< pair<const Key, T> > // unordered_map::allocator_type
// > class unordered_map;
int STL_Hash_Test(int argc, char **argv)
{
    std::unordered_map<int, std::string> hashIntStrMap;
    std::unordered_map<Usr_Key, Usr_Type,
        Usr_HashKey, Usr_HashPredicate> hashObjMap;

    hashIntStrMap[5] = "name string 1";
    Usr_Key key(1, "first");
    hashObjMap[key] = Usr_Type("title", "segment", "description");

    //std::unordered_map<Usr_Key, Usr_Type,
    // Usr_HashKey, Usr_HashPredicate> :: const_iterator theIterator;
    for ( auto iter = hashObjMap.begin() ; iter != hashObjMap.end() ; iter++ )
    {
        std::cout << iter->first
                  << " "
                  << iter->second
                  << " : "
                  << iter->second
                  << endl;
    }

    return 0;
}

/*
 * 主函数
 */
int main(int argc, char **argv)
{
    using namespace std;

    cout << "Hello world!" << endl;

    /*
     * const grammer
     */
    const string cnstStr = "const string";
    string varStr("variable string");

    basic_string <char>::const_iterator itC;
    basic_string <char>::iterator itV;

    itV = varStr.begin();
    itC = cnstStr.begin(); // as error: itV = cnstStr.begin();

    /*
     * enum example
     */
    enum Alert { green, yellow, election, red }; // 传统枚举
    //Alert a1 = 7; // 错误，传统枚举不是强类型的，a没有数据类型
    int a2 = red; // 正确，Alert 默认转换成 int
    // 新的具有类域和强类型的枚举类
    enum class Color
    {
        red, blue
    };
    // 枚举类的枚举值在类的外部时不可见的
    //int a3 = blue; // 错误，blue并没有在类域中
    // 不会默认地转换成int
    //Color c = 7; // 错误，没有默认的 int 到 Color 的转换
    int a4 = Alert::red; // 在 C++98中是错误的，但是在C++0x中是正确的
    //int a5 = Color::blue; // 错误，没有Color到int的默认转换
    Color a6 = Color::blue; // 正确

    enum class CColor : char // compact representation
    {
        red, blue
    };
    // 默认情况下，枚举值的底层数据类型为 int
    enum class TrafficLight
    {
        red, yellow, green
    };
    // E的体积是多大呢？
    enum E { E1 = 1, E2 = 2, Ebig = 0xFFFFFFF0U };
    // 不管旧的规则怎么定义，比如依赖于实现等
    // 现在我们可以指定枚举值的底层数据类型
    enum EE : unsigned long { EE1 = 1, EE2 = 2, EEbig = 0xFFFFFFF0U };
    // 指定枚举值的底层数据类型，使得前向声明成为可能
    enum class Color_code : char; // (前向) 声明
    void foobar(Color_code *p); // 前向声明的使用
    // 定义
    enum class Color_code : char
    {
        red, yellow, green, blue
    };

    /*
     * 常量表达式（constexpr）
     */
    constexpr int x1 = bad|eof; // ok

    constexpr Point origo(0,0);
    constexpr int z = origo.x;

    constexpr Point a[] = {Point(0,0), Point(1,1), Point(2,2) };
    constexpr int x = a[1].x; // x 变成 1

    int some_value[GetFive() + 5]; // 欲产生 10  个整数的阵列。合法的C++11语句


    /*
     * 测试 initialization list
     */
    vector<double> v = { 1, 2, 3.456, 99.99 };
    list< pair<string, string> > languages =
    {
        {"Nygaard","Simula"}, {"Richards","BCPL"}, {"Ritchie","C"}
    };
    map< vector<string>, vector<int> > years =
    {
        { {"Maurice","Vincent", "Wilkes"},
            {1913, 1945, 1951, 1967, 2000}
        },
        { {"Martin", "Ritchards"},
            {1982, 2003, 2007}
        },
        { {"David", "John", "Wheeler"},
            {1927, 1947, 1951, 2004}
        }
    };

    Init_F( {1,2});
    Init_F( {23,345,4567,56789});
    Init_F( {}); // 以空列表为参数调用f()
    //Init_F {1,2}; // 错误：缺少函数调用符号( )
    years.insert( {{"Bjarne","Stroustrup"},{1950, 1975, 1985}});

    vector<double> v1(7); // 正确: v1有7个元素
    //v2 = 9; // 错误: 无法将int转换为vector
    //vector<double> v3 = 9; // 错误: 无法将int转换为vector

    void f(const vector<double>&);
    //Init_F(9); // 错误: 无法将int转换为vector

    vector<double> v4 {7}; // 正确: v1有一个元素，其值为7
    v1 = {9}; // 正确，v1现在有一个值为9的元素
    vector<double> v6 = {9}; // 正确: 有一个值为9的元素
    Init_F( {9}); // 正确: f函数将以{ 9 }为参数被调用

    vector< vector<double> > vs =
    {
        // 正确: 显式构造（10个元素，值为double的默认值）
        vector<double>(10),
        vector<double>{10}, // 正确：显式构造（1个元素，值为10）
        //10 //错误 ：vector的构造函数是显式的
    };

    /*
     * decltype grammer
     */
    const std::vector<int> vecint(1);
    auto av = vecint[0]; // av 為 int 类型
    decltype(vecint[0]) dcltpb = 0; // b 为 const int& 类型，
    // 即 std::vector<int>::operator[]（size_type）const 的回返类型

    /*
     * Lambda statement
     */
    vector <int> numbers(10);
    generate(numbers.begin(), numbers.end(),
             [] {return rand() % 100;});
    int odd_count = 0;
    for_each(numbers.begin(), numbers.end(),
             [&odd_count](int value)
    {
        if (value % 2 != 0) odd_count++;
    });
    int seqStep = 2;
    int seqValue = -seqStep;
    vector<int> seq(10);
    generate(seq.begin(), seq.end(),
             [&seqValue, seqStep] {return seqValue += seqStep;});
    seqValue = -seqStep;
    generate(seq.begin(), seq.end(),
             [seqValue, seqStep]() mutable {return seqValue += seqStep;});
    auto lamdaF = [](int x, int y) -> int
    {
        x *= x;
        return x + y;
    };

    /*
    * 右值引用
    */
    BigType bigVar;
    BigType& r1 = bigVar; // OK: 将r1绑定到变量a(一个左值)
    //BigType& r2 = BigTypeFunc(); // Error: 其返回的是一个右值，无法绑定

    BigType&& rr1 = BigTypeFunc(); // OK: 将rr1绑定到临时变量
    //BigType&& rr2 = bigVar; // Error: 无法将右值引用rr2绑定到左值a

    /*
     * 静态（编译期）断言由一个常量表达式及一个字符串文本构成
     */
    //static_assert(sizeof(long) >= 8,
    // "64-bit code generation required for this library.");


    /*
     * map, pair and hash example
     */
    STL_Map_Test(argc, argv);
    STL_Hash_Test(argc, argv);

    return 0;
}

参考资料：