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))