2.1 基本内置类型
C++中包括 算数类型(arithmetic type) 和 空类型(void) 的数据类型，其中，算数类型包括字符、整型数、布尔值和浮点数；空类型不对应具体的值，当函数不返回值时用void作为返回类型
2.1.1算数类型
对于数组或者字符串，a[i++] / a[i—]先执行 a[i] 在执行i++/ i —; 而a[++i] / a[—i] 先执行 i++/ i— 然后执行 a[i]
Unsigned 和 signed：
无符号：只有正数
有符号: 分为 正数和负数 范围为 -128~127
unsigned和signed转换：unsigned表示为 1111 1111，为255，转换为signed后，符号位1代表是负数（最高位为符号位），数值位转换成十进制后是127，按照补码的定义结果为-1；当signed转为unsigned时，最高位不表示符号位。
补码：
1、对于正数，补码与原码相同；
2、对于负数，数值位的绝对值取反后在最低位加1。PS：负数转整数也是取反后最低位加1（不是减1）
字面值常量
整型、浮点型：
以0 开头的为 八进制 ： 024
以0x或者0X开头的为十六进制： 0x14
其他情况为十进制
字符型：
单引号括起来的为 char型字面值、双引号括起来的为 字符串型字面值
作用：用于显示单个字符
语法：char 字符名 = '字符值'
注意：
1. 要用单引号括起来
2. 单引号内只能由一个字符，不可以是字符串
3. C和C++中字符型变量只占用1个字节
4. 字符型变量不是把字符本身存放到内存中，而是将对应的ASCII编码放入到存储单元中
#include<iostream>
using namespace std;
int main()
{
// 1.字符型变量的创建方式
char ch = 'a';
cout << ch << endl;
// 2.字符型变量所占内存大小
cout << "char字符型所占内存大小：" << sizeof(ch) << endl;
// 3.字符型变量常见错误
//char ch2 = "b"; // 创建字符型变量要用 单引号
//char ch2 = 'abcdef'; // 创建字符型变量单引号内只能有一个字符
// 4.字符型变量对应的ASCII编码 转为 int 型
cout << "char字符型对应ASCII编码：" << (int)ch << endl;
return 0;
}
输出结果：
常见字符型ASCII码：a - 97 A - 65
ASCII码：
1. 0-31 非打印的控制字符
2. 32-126 键盘上可以找到的字符
修改类型：
通过添加前后缀来改变字符类型
2.2 变量
2.2.1 变量定义
int：内置int 全局int默认初始化为0，函数体内的不被初始化 如果初始化会为 未定义的奇异值
string： 内置的string 无论是全局还是函数体内 默认初始化均为 空字符串
2.2.2 变量声明与定义
声明：将一个变量的名字让电脑知道 没有初始化 变量前+ 关键字 extern
定义：声明并初始化变量，需要申请存储空间
如果在函数体内初始化一个由extern 标记的变量会报错 变量可以多次声明但只能定义一次
2.3 复合类型
指针
32位 指针占用内存 4个字节
64位 8个字节
作用：获取对象的地址 （指针本身是对象）
指针值：对象的地址 类型要匹配
四种状态：
1.指向一个对象
2.指向邻近对象所占空间的下一个位置
3.空指针，即指针没有指向任何对象
4.无效指针，除以上3种外的情况
void* 指针，可以指向任何类型的对象的地址；一般用于指针比较、作为函数的输入或输出、赋值给另一个void*指针
判断指针是否合法：
将指针用if 进行判断
空指针：
1.用于给指针变量初始化
int *p = NULL;
2.空指针不能进行访问
const 与指针
int main()
{
int a = 10, b = 10;
//1. const 修饰指针 常量指针
const int *p = &a; // 常量指针，指针指向的值不可以改， 指针的指向可以改
// *p = 20; //指针指向的值不可以改
p = &b; // 指针的指向可以改
//2. const 修饰常量 指针常量
int * const p2 = &a;
*p2 = 100; // 指针指向的值可以改
// p2 = &b; // 指针的指向不可以改
//3. const 修饰常量和指针
const int * const p3 = &a;
// *p3 = 100; // 指针指向的值不可以修改
// p3 = &b; // 指针的指向不可以修改
}
指针与数组、指针与函数
指针与数组
//指针与数组
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
int *p = arr; // p指向数组的首地址
// cout << *p << endl;
// 指针访问 数组任意位置 p++ 相对于指针p向后移动了4个字节
// cout << *(p+1) << endl;
for(int i = 0; i < sizeof(arr) / sizeof(int); ++i)
{
cout << *(p++) << " ";
}
指针与函数
利用地址传递实现函数
// 数组以参数的形式传出时会成为一个指针类型，失去了数组的属性， 因此必须传入一个数组的长度 且 数组默认的传递方式均为 地址传递，不能进行值传递
传递引用时，同时将数组长度也传递进去了，所以传入时必须为相应长度的数组。并且，在传递引用时，需要注意用（）将&aa括起来，否则编译器报错。
//值传递数组
void printdz(int a[])
{
cout<<"子函数里a0的地址为"<<&a[0]<<endl;
cout<<"子函数里a的地址为"<<a<<endl;
//a本身即为指针 无需取地址符
cout<<"子函数里a1的首地址为"<<&a[1]<<endl;
a[1]=2;
}
int main()
{
int a[10]={1};
cout<<"主函数里a的首地址为"<<&a[0]<<endl;
cout<<"开始的a1为 "<<a[1]<<endl;
printdz(a);
cout<<"函数里改过的a1 为"<<a[1]<<endl;
return 0;
}
//引用传递数组
void printdzyy(int (&aa)[10])
//引用就可以传递数组长度 因此需要写出数组大小
{
cout<<"函数里aa的地址为"<<aa<<endl;
}
int main()
{
int a[10]={1};
int b[5]={1};
cout<<"主函数里a[0]的首地址为"<<&a[0]<<endl;
printdzyy(a);
//printdzyy(b); incorrect //如果传入b则编译不通过
return 0;
}
#include<iostream>
using namespace std;
void bubbleSort(int *arr, int len)
{
for(int i = 0; i < len; ++i)
{
for(int j = 0; j < len; ++j)
{
if(arr[i] < arr[j])
{
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
void printArr(int *arr, int len)
{
for(int i = 0; i < len; ++i)
{
cout << arr[i] << " ";
}
cout << endl;
}
int main()
{
int arr2[10] = {4,3,6,9,1,2,10,8,7,5};
int len = sizeof(arr2) / sizeof(int);
cout << "排序前：" << endl;
printArr(arr2, len);
bubbleSort(arr2, len);
cout << "排序后：" << endl;
printArr(arr2, len);
}
引用
引用：引用类型的初始值必须是一个==对象且类型需要相同==
int 可以引用 double 类型（窄化操作）
引用一旦初始化后，就不可以更改
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int &b = a; // 引用必须初始化
int c = 20;
b = c; // 为赋值操作 不是更改引用，引用在初始化后不可以更改
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}
引用做函数参数
1.值传递
// 1. 值传递 // 值没有发生改变, 值传递不改变实参数据 形参不会修饰实参
void mySwap01(int a, int b)
{
int temp = a;
a = b;
b = temp;
cout << "函数内 a = " << a << endl;
cout << "函数内 b = " << b << endl;
}
2.地址传递
// 2. 地址传递 用形参修饰实参 用指针接受地址
void mySwap02(int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
3.引用传递
// 3. 引用传递
void mySwap03(int &a, int &b)
{
int temp = a;
a = b;
b = temp;
}
int main()
{
// 引用做函数参数
int a = 5, b = 10;
// 1. 值传递
// mySwap01(a, b); // 值没有发生改变, 值传递不改变实参数据 形参不会修饰实参
// cout << "值传递 交换后 a = " << a << endl;
// cout << "值传递 交换后 b = " << b << endl;
// 2. 地址传递 形参会修饰实参
// mySwap02(&a, &b);
// cout << "地址传递 交换后 a = " << a << endl;
// cout << "地址传递 交换后 b = " << b << endl;
// 3.引用传递 形参会修饰实参
mySwap03(a, b);
cout << "引用传递 交换后 a = " << a << endl;
cout << "引用传递 交换后 b = " << b << endl;
return 0;
}
引用做函数的返回值
1.不能返回局部变量的引用
#include<iostream>
using namespace std;
// 引用做函数的返回值
// 1.不能返回局部变量的引用
int &test1()
{
int a = 10; // 局部变量存放在 栈区
return a;
}
// 2.函数的调用可以作为左值
int main()
{
int &ref = test1();
cout << "ref = " << ref << endl; // 第一次结果正确
cout << "ref = " << ref << endl; // 第二次结果错误
return 0;
}
2.函数的调用可以作为左值
#include<iostream>
using namespace std;
// 引用做函数的返回值
// 2.函数的调用可以作为左值
int& test2()
{
static int a = 10;// 静态变量 存放在全局区 由系统释放
return a;
}
int main()
{
int &ref2 = test2();
cout << "ref2 = " << ref2 << endl; // 第一次结果正确
cout << "ref2 = " << ref2 << endl; // 第二次结果错误
test2() = 100; // 函数的调用做左值 ，如果函数的返回值是引用，则该函数调用可以作为左值
cout << "ref2 = " << ref2 << endl; // 第一次结果正确
cout << "ref2 = " << ref2 << endl; // 第二次结果错误
return 0;
}
引用的本质
本质：引用的本质在C++内部中本质为 指针常量
常量引用
使用场景：用来修饰形参，防止误操作
#include<iostream>
using namespace std;
void showValue(const int &val)
{
val = 10000;
cout << "val = " << val << endl;
}
int main()
{
// 常量引用
// 使用场景：修饰形参， 防止误操作
int a = 10; // 变量a存放在栈区
// int &ref= 10;
// 引用必须引用一块合法的内存空间，若引用数值10时，
// 10在堆区中，是一个字面量不能直接引用。此时需要添加const关键字
// 添加const 后编译器将代码修改为用一个临时变量存储 该值， int temp = 10; const int &ref = temp; 但是不能修改
// 常量引用
const int &ref = 20;
//ref = 30; // 加入const后变为只读，不可修改
// 修饰形参， 防止误操作
int b = 100;
// 通过函数打印b
showValue(b);
// 因为 showValue(int &val) 是引用传递，因此在函数内可以通过形参来修改实参的值， 此时为了防止数据被修改，将其利用const 修饰形参 避免误操作
cout << "b = " << b << endl;
//cout << ref << endl;
system("pause");
return 0;
}
引用与指针区别：
引用：绑定一个对象，必须在定义是赋值，本身不是对象；不能更换对象
指针：指向一个对象的地址，本身为对象，无须在定义时赋值；且允许进行赋值和拷贝；允许更换对象
判断值的真实含义：
从右向左阅读定义，离得最近的为其类型
2.4 const限定符
const 对象必须要初始化
若想在多个文件之间共享 const 对象，需要添加 extern关键字
普通指针只能指向普通常量，const 指针只能指向const常量 且 常量指针不能赋值
顶层const
顶层const 表示指针本身是常量；在进行拷贝时顶层const不受影响
底层const 表示指针指向的对象是常量
简单而言就是可以修改值的const为底层const，不能修改的为顶层const
//顶层const
int i = 0;
int *const p1 = &i; // 不能改变p1的值，为顶层const
const int ci = 42; // 不能改变ci的值，顶层const
const int *p2 = &ci; // 可以修改p2的值，底层const
const int *const p3 = p2; // 左侧的const 为底层，右侧的为顶层
const int &r = di; // 用于声明应用的const均为底层const
consterxpr变量：由编译器验证是否是一个常量表达式，且声明为consterxpr的变量一定是一个常量，必须用常量表达式进行初始化 ^tasctu
2.5 处理类型
C++11 新特性：
别名声明
using SI = XXX; // SI 是XXX的同义词
auto 类型说明符:
编译器通过初始值来推断变量的类型，因此变量必须初始化
decltype类型指示符: 选择并返回操作数的数据类型：
decltype((variable))： 结果为引用;
decltype(variable) ： 结果为变量，只有当variable为引用（表达式是引用）时，其结果才是引用 ^q1zzxe
auto与decltypye 区别：
1.auto 根据变量的初始值来判断其类型；decltype 根据括号及括号内的内容判断
2.auto 有时候推断的结果和初始值类型不完全一样 会忽略掉顶层const 把底层const保留下来；而decltype则会保留顶层const
