C++语言引用
#######基本数据类型引用
类型：&b = a (即：a的别名是b；b的地址指向a)
#include<iostream>
using namespace std;
{
int a = 3;
int &b = a;//引用必须初始化；b地址指向a
b = 10;
cunt << a << endl;// 对别名操作，即是对本身进行操作 a为10
return 0;
}
#######结构体类型的引用
定义一个结构体，结构体名字为Coor(这是个坐标),里面有两个成员：x,y
typedef struct
{
int x;
int y;
}Coor;
我们在函数当中使用所定义的结构体
#include<iostream>
using namespace std;
int main(void)
{
Coor c1;//先定义结构变量c1
Coor &c = c1;//给c1起个别名叫c----->所谓别名c:该别名地址&指向该对象本身&c—>c1
c.x = 10;//赋值操作
c.y = 20;
count << c1.x << c1.y;//打印出来结果10，20
return 0;
}
#######指针类型的引用
类型：
*&指针引用名 = 指针 (*&q = p)
#include<iostream>
using namespace std;
int main(void)
{
int a= 10;
int *p = &a;//*p(指针p)指向a(是a所对应的对象，不是a的地址，而是a得地址所指向的值a)
int *&q = p;//p的别名为q
*q = 20;//20赋值给*q，也即20赋值给*p，也即把20赋值给a
cout << a << endl;//a = 20
return 0;
}
#######引用作函数参数
&指针引用名 = 指针(&q = p);对别名q进行的任何操作都会改变a的值
C 语言中，将两个值进行交换
void fun(int *a,int *b) //两个整形变量作为函数形參
{
int c = 0;//定义一个空间变量非c
c = *a;
*a = *b;
*b = c;//完成了实际参数a,b 之间的调换
}
//在调用中：
int x= 10,y=20;
fun(&x,&y);//对x,y进行取地址
C++引用作函数参数:
void fun(int &a,int &b) //void fun ( int 指针，int 指针)
{
int c = 0;
c = a;
a = b;
b = c;
}
//在调用中：
int x= 10,y=20;
fun(x,y);//
C++语言const关键字
const关键字控制变量是否能够变化
1.const与基本数据类型
C 语言中：
int x = 3; //变量
const int x = 3;//已经把x值定义为3，不可修改
| 变量名 | 存储地址 | 存储内容 |
|---|---|---|
| x | &x | 3 |
2.const与指针类型
int x = 3; const int *p = &x; //const 此时修饰的是*p，所以对*p重新赋值是不正确的
//p = &y；正确 //*p = 4；错误——>const对 「*p」进行修饰，不可更改
「>」>>>>> p指向x，不能再指向y。*p = &x 完全等价——>都表示地址
| 变量名 | 存储地址 | 存储内容 |
|---|---|---|
| x | &x | 3 |
| p | &p | &x |
int x = 3;int *const p = &x;
//p = &y;错误的 ——>const 修饰的是p,指针p 只能指向一个地址
| 变量名 | 存储地址 | 存储内容 |
|---|---|---|
| x | &x | 3 |
| p | &p | &x |
3.const与引用
int x = 3; const int &y = x ; //const 定义了一个引用y「&y」;y是x的别名
//x = 10;正确 //y = 20;错误——>y是x的别名，对x修改可以改变y(对y的修改可以改变x)，但是y是被const修饰，不可改变
| 变量名 | 存储地址 | 存储内容 |
|---|---|---|
| x | &x | 3 |
C++函数新特性
#######1. 函数参数默认值
一定要把函数参数默认写在最右端；在没有实参用默认值，否则就用参数调用默认值。
void fun (int i, int j = 5, int k = 10);
void fun (int 1, int j = 5,int k); ————>❌
#include<stdlib.h>
using namespace std;
//函数方法的声明
void fun(int i = 30,int j = 20, int k = 10);
void fun(double i ,double j);
int main(void)
{
fun(1.1,2.2); ————————>函数体
fun(1,2);
system("pause");
return 0;
}
//函数方法的实现 调用
void fun(int i , int j , int k)
{
count<<i<<","<<j<<","<<k<<endl; ————>1,2,10
}
void fun(double i, double j)
{
count<<i<<","<<j<<endl;——————>1.1,2.2
}
#######2.函数重载
在相同作用域内，用同一函数名定义的多个函数，参数个数和参数类型不同
int getMax(int x, int y, int z) ————————>getMax_int_int_int(计算机调用过程方法)
{
//to do
}
double getMax(double x, double y)———————>getMax_double_double
{
//to do
}
3.内联函数
inline:编译时将函数体 代码和实参代替函数调用语句。
1.内联编译是建议性的，由编译器决定。
2.逻辑简单，调用频繁的函数建议使用内联。
3.递归函数无法使用内联方式。
inline int max(int a, int b, int c);
int main()
{
int i = 10, j = 20,k = 30,m;
m = max(i,j,k);————————————>化解如下代码👇
count <<"max = "<<m<<endl;
return 0;
int main()
{
int i = 10, j = 20,k = 30,m;
「int a,b,c; ——————————>等同于👆
a= i; b = j; c = k ;
if(b>a) a= b ;
if(c>a) a=c;
m = a; 」
count <<"max = "<<m<<endl;
return 0;
总结：
函数参数默认值：实参覆盖默认值
函数重载 名称相同参数可辨
内联函数 inline 高效 有条件
C++内存管理
内存本质是资源，操作系统管理内存资源，要申请/归还资源
内存的申请和释放
申请内存： new 。 int *p = new int;//用指针(p*)来接收new运算符申请到的地址
释放内存： delete 。delete p//delete后面跟相应的指针
⚠️new、delete 只是运算符不是函数
#######申请和释放块内存
int *arr = new int[10];//申请块内存
delete [ ]arr;// 释放块内存
内存操作的注意事项
C语言：void *malloc(size_t size);
void free(void *memblock);
C++ new
delete
配套使用，切莫混搭
申请是否成功
//iOS懒加载
int *p = new int [1000];
if (NULL == p)
{
//内存分配失败——————>if判断中为空后，可以再进行分配(iOS懒加载)
}
delete [ ]p;
p = NULL ;//相应地指针赋为空，避免各种各样的错误
相关C++内容：
C++远征之起航篇、C++远征之离港篇、C++远征之封装篇、C++远征继承篇、C++远征多态篇、C++远征模版篇
