C++11使用=或者{} 初始化随记

在C++11中可以使用=或者{}就地初始化

struct st
{
    int a{0};
    int b=1;
};

struct init
{
    //std::string a("test"); //编译通不过 不能用括号
    std::string b {"test"};
};

=和{}可以和初始化列表一起使用，但初始化列表总是后作用于=和{}

初始化向量

 int arr[] = {1, 3, 5};
 std::cout << arr[0] << " " << arr[1] << " " << arr[2] << std::endl;

//数组初始化
int arr1[]{2,4,6};
std::cout << arr1[0] << " " << arr1[1] << " " << arr1[2] << std::endl;

 std::map<int,int> m{ {1,11},{2,22},{3,33} };
 std::cout << m[1] << " " << m[2] << " " << m[3] << std::endl;
 //11 22 33

 std::vector<int> vec{1, 3, 5};

{}初始化是唯一一种可以防止类型收窄的初始化方式。所谓的类型收窄其实就是新类型不可以表示原来类型的情况，在类型转换的过程中数据丢失。

        const int x = 1024;
        const int y = 10;

        char a = x;       //收窄，编译可以通过
        char *b = new char(1024);//收窄，编译可以通过

       // char c = {x};   //收窄，编译无法通过
        char c = {y};   //收窄，编译可以通过
        char d = {y};   //编译可以通过
       // unsigned char e {-1}; //收窄，编译无法通过

        float f{ 7 }; //编译可以通过
       // int g { 2.0f };       //收窄，编译无法通
       // float *h = new float{1e48};  //收窄，编译无法通
        float i = 1.2l; //可以通过编译

类中使用例子

class Object
{
public:
    Object();
    ~Object();
    int version() const;
    std::string objectName() const;
private:
    class ObjectData;
    const ObjectData* const d;
};

class Object::ObjectData
{
public:
    int         m_version{1};
    std::string m_objectName{"Object"};
};

Object::Object()
    :d(new ObjectData())
{

}

Object::~Object()
{
    delete d;
}

int Object::version() const
{
    return d->m_version;
}

std::string Object::objectName() const
{
    return d->m_objectName;
}

Qt向量例子

    QVector<int> vec1{111,333};
    qDebug() << vec1;

    QList<int> lst{1,2,3,4};
    qDebug() << lst;

    QMap<int,int> map{  {1,11},{2,22},{3,33} };
    qDebug() << map;

打印结果

QVector(111, 333)
(1, 2, 3, 4)
QMap((1, 11)(2, 22)(3, 33))