一、内存的分区模型
1.程序运行前
?1.1全局区：
?
#include<iostream>
using namespace std;
//全局变量
int g_a = 10;
int g_b = 10;
//const全局量
const int c_g_a = 10;
const int c_g_b = 10;
int main() {
//全局区 全局变量 静态变量 常量（字符串常量）
cout << "全局变量g_a的地址为" << (int)&g_a << endl;
cout << "全局变量g_b的地址为" << (int)&g_b << endl;
//静态变量 在普通变量前加static，数据静态变量
static int s_a = 10;
static int s_b = 10;
cout << "静态变量s_a的地址为" << (int)&s_a << endl;
cout << "静态变量s_b的地址为" << (int)&s_b << endl;
//常量 字符串常量 const常量
cout << "字符串常量 的地址为：" << (int)& "hello world" << endl;
//常量 const修饰的全局常量和局部常量
//const全部变量
cout << "const全局常量c_g_a的地址为" << (int)&c_g_a << endl;
cout << "const全局常量c_g_b的地址为" << (int)&c_g_b << endl;
//const修饰的局部常量
const int c_l_a = 10;
const int c_l_b = 10;
cout << "const局部常量c_l_a的地址为" << (int)&c_l_a << endl;
cout << "const局部常量c_l_b的地址为" << (int)&c_l_b << endl;
//创建普通的局部变量
int a = 10;
int b = 10;
cout << "局部变量a的地址为" << (int)&a << endl;
cout << "局部变量b的地址为" << (int)&b << endl;
system("pause");
return 0;
}2.程序运行后
栈区：
#include<iostream>
using namespace std;
//栈区数据注意事项，----不要返回局部变量的地址
//栈区的数据由编译器管理开辟和释放
int* func(int b) {
b = 100;
int a = 10;//局部变量 存放在栈区，栈区的数据在函数执行完后自动释放
return &a;//返回局部变量的地址
}
int main() {
//接受func 函数的返回值
int* p = func(1);
cout << *p << endl;//第一次可以打印正确的数字。
cout << *p << endl;//跌二次就乱码了。
system("pause");
return 0;
3.new操作符
#include<iostream>
using namespace std;
//1.new的基本语法
int * func() {
//在堆区创建整型的数据
//new返回是该数据类型的指针
int* p = new int(10);
return p;
}
void test01() {
int * p = func();
cout << *p << endl;
cout << *p << endl;
cout << *p << endl;
//堆区的数据，由程序员管理开辟，管理释放
//如果想释放堆区的数据，利用关键字delete
delete p;
//cout << *p << endl;//内存已经被释放，再次访问就是非法操作，会报错
}
void test02() {
//创建10整型数据的数组，在堆区
int* arr = new int[10];//10代表数组中有10个元素
for (int i = 0; i < 10; i++) {
arr[i] = i + 100;//给10个元素赋值 100~109
}
for (int i = 0; i < 10; i++) {
cout << arr[i] << endl;
}
//释放堆区数组
//释放数组的时候，要加[]才可以
delete[] arr;
}
//2.在堆区利用new开辟数组
int main() {
test01();
test02();
system("pause");
return 0;
}二、引用
1.引用的基本使用
2.引用的注意事项
（1）引用必须初始化
（2）引用在初始化后不可以修改
#include<iostream>
using namespace std;
int main() {
//1.引用 必须初始化
//int& b = a;//这是错误代码，必须要初始化
int a = 10;
int& b = a;
//引用初始化后不可更改
int c = 20;
//int& b = c; 已经是a的别名就不能再是b的别名了。
b = c;//这是赋值操作，不是引用
system("pause");
return 0;
}3.引用做函数参数
作用：函数传参时，可以利用引用的技术让形参修饰实参
优点：可以简化指针修改实参
#include <iostream>
using namespace std;
//交换函数
//1 值传递
void mySwap01(int a,int b) {
int temp = a;
a =b;
b = temp;
}
//2.地址传递
void mySwap02(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
cout << *a << endl;
cout <<* b << endl;
}
//3.引用传递
void mySwap03(int &a,int &b) {
int temp = a;
a = b;
b = temp;
}
int main() {
//值传递，形参不会改变实参。
int a = 10;
int b = 20;
mySwap01(a, b);
//cout << a << endl;
//cout << b << endl;
//地址传递会改变实参
mySwap02(&a, &b);
//引用传递形参也会改变实参
mySwap03(a, b);
system("pause");
return 0;
}4.引用做函数返回值
作用：引用是可以 作为函数的返回值存在的
注意：不要返回局部变量引用
用法：函数调用作为左值
#include <iostream>
using namespace std;
//引用做函数的返回值
//1.不要返回局部变量引用
int & test01() {
int a = 10;//局部变量存放在四区中的 栈区
return a;
}
//2.函数的调用值可以作为左值
int& test02() {
static int a = 10;//静态变量，存放在全局区，全局区上的数据在程序结束后系统释放
return a;
}
int main() {
int& ref = test01();
cout << ref << endl;//第一次结果正确，是因为编译器做了保留
cout << ref << endl;//第二次结果错误，是因为a的内存已经释放。
int& ref2 = test02();
cout << ref2 << endl;
test02() = 1000;//返回值是a a=1000;ref2就是a的别名
cout << ref2 << endl;
cout << ref2 << endl;
cout << ref2 << endl;
system("pause");
return 0;
}5.引用的本质
本质：引用的本质在C++内部实现是一个指针常量
#include <iostream>
using namespace std;
//发现是引用，转换为int * const ref=&a;
void func(int &ref) {
ref = 100;//ref是引用，转换为*ref=100;
}
int main() {
int a = 10;
//自动转换为 int * const ref =&a; 指针常量是指针的方向不可改，也说明为什么引用不可改
int& ref =a;
ref = 20;//内部发现ref是引用，自动帮我们转换为 *ref=20；
cout << "a" << a << endl;
cout << "ref:" << ref << endl;
system("pause");
return 0;
}6.常量引用
作用：常量引用主要用来修饰形参，防止误操作
在函数 形参列表中，可以加const修饰形参，防止形参改变实参
#include <iostream>
using namespace std;
void showValue(const int& val) {
//val = 1000;
cout << val << endl;
}
int main() {
//常量引用
//场景：常量引用主要用来修饰形参，防止误操作
//int a = 10;
//int& ref = 10;//引用必须引一块合法的内存空间
//加上const之后 编译器将代码修改 int temp=10; const int &ref=temp;
//const int& ref = 10;
//ref = 20;//加入const之后变为只读，不可修改
int a = 100;
showValue(a);
cout << a << endl;
system("pause");
return 0;
}三、函数提高
1.函数的默认参数
#include<iostream>
using namespace std;
//函数的默认参数
//如果自己传了实参就用实参，没有传实参就是默认值。
//语法 返回值类型 函数名=（形参，默认值）{ }
int func(int a, int b=20,int c=30) {
return a + b + c;
}
//注意事项
//1.如果某个位置已经有了默认参数，那么从这个位置往后，从左到右都必须有默认值
//int func2(int a,int b,int c=10,int d) {
//return a + b + c + d;
//}
//2.如果函数声明有默认参数，函数实现就不能有默认参数 声明和实现只能有一个有默认参数
//函数的声明
int func2(int a=10, int b=10);
int func2(int a, int b){
return a + b ;
}
int main() {
cout << func(10) << endl;;
system("pause");
return 0;
}2.函数的占位参数
描述：C++中函数的列表里可以有占位参数，用来做占位，调用函数时必须填补该位置
语法： 返回值类型? 函数名（数据类型）{
}
#include<iostream>
using namespace std;
//占位参数
//返回值类型 函数名（数据类型） { }
//占位参数 ，还可以有默认参数
void func(int a,int) {
cout << "tiis is a func" << endl;
}
int main() {
func(10, 10);
system("pause");
return 0;
}3.函数重载
作用：函数名可以相同，提高复用性
3.1函数重载的概述
满足条件：
1.同一作用域下
2.函数名相同
3.函数参数类型不同或者个数不同或者顺序不同
注意：函数的返回值不可以作为函数重载的条件
#include<iostream>
using namespace std;
//函数重载
//作用：函数名可以相同，提高复用性
//满足条件：
//1.同一作用域下
//2.函数名相同
//3.函数参数类型不同或者个数不同或者顺序不同
void func() {
cout << "tiis is a func" << endl;
}
void func(int a) {
cout << "tiis is a func!" << endl;
}
int main() {
system("pause");
return 0;
}3.2函数重载的注意事项
引用作为重载的条件
函数重载碰到函数默认参数
#include<iostream>
using namespace std;
//1.引用作为重载的条件
void func(int &a) {//int &a=10;这是不合法的
cout << "1" << endl;
}
void func(const int& a) {//const int &a=10; 这是合法的
cout << "2" << endl;
}
//函数重载碰到函数默认参数
void func2(int a,int b=10) {
cout << "1" << endl;
}
void func2(int a ) {
cout << "1" << endl;
}
int main() {
int a = 10;
func(a);//调用的是第一个函数
func(10);//调用的是第二个函数
func2(10);//当函数重载碰到默认参数，出现二义性，报错，尽量避免这种情况
func2(10, 20);//这是正常调用
system("pause");
return 0;
}四、类和对象
1.封装
1.1封装的意义
1.2struct和class的区别
1.3成员属性设置为私有
2.对象的初始化和清理
3.C++对象模型和this指针
4.友元
5.运算符重载
6.继承
7.多态