C++：常见类型的初始化
https://blog.csdn.net/qq_34801642/article/details/104041259
1. 背景
2. 初始化
1. 背景
常见类型 包含
内置类型 整型(布尔型，字符型，整型)、浮点型
复合类型 引用、指针、数组
标准库类型 string、vector
2. 初始化
整型和浮点型初始化时会自动进行类型转换。
#include <iostream>
using namespace std;
int main()
{
int i1 = 1;
const int i2 = 1;
double d1 = 3.14;
const double d2 = 3.14;
int x1 = i1; // int <- int
int x2 = i2; // int <- const int
int x3 = d1; // int <- double
int x4 = d2; // int <- double
const int x5 = i1; // const int <- int
const int x6 = i2; // const int <- const int
const int x7 = d1; // const int <- const double
const int x8 = d2; // const int <- const double
return 0;
}
引用类型初始化时类型需严格匹配。若引用类型含有const，可用任何表达式作为初始值。若类间存在继承关系，则基类引用可以绑定派生类对象。
#include <iostream>
using namespace std;
class A
{
public:
int a;
};
class B: public A
{
public:
int b;
};
main()
{
int i1;
const int i2 = 1;
double d1 = 3.14;
const double d2 = 3.14;
int &x1 = i1; // int & <- int
// int &x2 = i2; //错误：int & <- const int
// int &x3 = d1; //错误： int & <- double
// int &x4 = d2; //错误： int & <- const double
//引用类型包含const，可用任何表达式作为初始值
const int &x5 = i1; // const int & <- int
const int &x6 = i2; // const int & <- const int
const int &x7 = d1; // const int & <- double
const int &x8 = d2; // const int & <- const double
const int &x9 = 1;
const int &x10 = 3.14;
//存在继承关系的类，基类引用可以绑定到派生类对象
A a;
B b;
A &a1 = b;// A& <- B
// B &b1 = a;//错误： B& <- A
return 0;
}
指针类型初始化时类型需严格匹配。若指针类型含有的const，则可以将非常量转换成常量。若类间存在继承关系，基类指针可以指向派生类对象。
#include <iostream>
using namespace std;
class A
{
public:
int a;
};
class B: public A
{
public:
int b;
};
main()
{
int i1;
const int i2 = 1;
double d1 = 3.14;
const double d2 = 3.14;
int *x1 = &i1; // int * <- int *
// int *x2 = &i2; //错误：int * <- const int *
// int *x3 = &d1; //错误： int * <- double *
// int *x4 = &d2; //错误： int * <- const double *
//指针类型包含const，指向常量的指针可用非常量初始化
const int *x5 = &i1; // const int * <- int *
const int *x6 = &i2; // const int * <- const int *
// const int *x7 = &d1; // 错误： const int * <- double *
// const int *x8 = &d2; // 错误： const int * <- const double *
//存在继承关系的类，基类指针可以指向派生类对象
A a;
B b;
A *a1 = &b;// A* <- B *
// B *b1 = &a;//错误： B* <- A *
return 0;
}
绑定指针的引用。初始化时，引用绑定对象的类型需要与初始对象的类型严格匹配。
#include <iostream>
using namespace std;
class A
{
public:
int a;
};
class B: public A
{
public:
int b;
};
main()
{
int i1, *p1;
const int i2 = 1, *p2;
double d1 = 3.14, *p3;
const double d2 = 3.14, *p4;
// int *&x1 = &i1; //错误：等号右边必须为左值
int *&x1 = p1;
// int *&x2 = p2; //错误：int *& <- const int *
// int *&x3 = p3; //错误： int *& <- double
// int *&x4 = p4; //错误： int *& <- const double
// const int *&x5 = p1; // 错误：const int *& <- int
const int *&x6 = p2; // const int *& <- const int
// const int *&x7 = p3; // 错误： const int *& <- double
// const int *&x8 = p4; // 错误： const int *& <- const double
A a, *pa;
B b, *pb;
A *&a1 = pa;// A *& <- *a
// A *&a1 = pb;//错误： A*& <- B
// B *&b1 = pa;//错误： B*& <- A
return 0;
}
数组初始化。数组一般用花括号初始化，数组间不能初始化、赋值和拷贝。
#include <iostream>
using namespace std;
main()
{
int i = 1;
const int ci = 1;
int x1[3];
int x2[3] = {1, 2, 3};
int x3[3] = {1, 3.14, ci};
const int x4[3] = {1, 3.14, ci};
//不能用一个数组初始化另一数组
// int i4 = i1;
return 0;
}
string初始化。
#include <iostream>
#include <string>;
using namespace std;
int main()
{
string s1;
string s2(s1);
string s3("abc");
string s4(3, 'a');//s4=aaa
string s5{"abc"};
string s6 = s1;
string s7 = "abc";
string s8 = 'a' + s1;//s8=a
// string s9 = 'a' + 'b' + s1;//错误：加号两边至少有一边是string类型
return 0;
}
vector初始化
#include <iostream>
#include <vector>;
using namespace std;
int main()
{
vector<string> vi1;
vector<string> vi2(vi1);
vector<string> vi3(3); //vi3包含3个元素
vector<string> vi4(3, "a"); //vi4包含3个元素，每个元素的初值为a
vector<string> vi5{"a", "b"}; //vi5包含2个元素，初值分别是a和b
vector<string> vi6 = vi1;
vector<string> vi7 = {"abc"};
return 0;
}
————————————————
版权声明：本文为CSDN博主「扶摇直上九万里wyh」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_34801642/article/details/104041259
