C++02

指针和引用

引用：某一个变量的别名。对引用的操作和对变量的操作完全一样。

基本数据类型引用：

#include<iostream>` `using namespace std;` `int main(){` `int a=3;` `int &b=a;`//引用必须初始化，否则编译时报错 `b=10;` `cout<<a<<endl;` `return 0;` `}

输出结果：10

a的别名是b。对b操作就是对a操作。

结构体类型的引用：

#include<iostream>` `using namespace std;` `typedef struct{` `int x;` `int y;` `}GOT7;` `int main(){` `GOT7 got7;` `GOT7 &Got=got7;` `Got.x=10;` `Got.y=11;` `cout<<got7.x<<" "<<got7.y<<endl;` `return 0;` `}

输出结果： 10 11

Got是got7的别名，对Got操作就是对got7操作。

指针类型的引用：

语法：*类型 &指针引用名=指针；

#include<iostream>` `using namespace std;` `int main(){` `int a=10;` `int *p=&a;` `int *&q=p;` `*q=20;` `cout<<a<<endl;` `return 0;` `}

输出结果：20

指针p指向a；为p起一个别名q，对q操作就是对p操作，对p操作就是对a操作。

引用作函数参数

#include<iostream>
using namespace std;
void fun(int &a,int &b){
int c=0;
c=a;
a=b;
b=c;
cout<<a;
cout<<b;
}
int main(){
int x=10;
int y=20;
fun(x,y);
return 0;
}

输出结果：20 10

define VS const

const与基本数据类型

const int x=2；//变量x成为了常量，x的值无法再更改。

const与指针类型

const int *p=null;①

const 只对*p有作用，对变量p没有作用；

无法通过*p来修改x的值，但是变量p还可以指向其他变量的地址；

#include<iostream>` `using namespace std;` `int main(){` `int x=2;` `int y=1;` `int const *p=&x; p=&y; cout<<*p<<endl;` `cout<<p<<endl;` `return 0;` `}

输出结果：1（换行）0x6bfee4

输出p是输出了p指向变量的地址，输出*p是p指向的变量的值。

int const *p=null;②

const修饰的p只能指向一个变量地址。

int *const p=null;③

p不能指向其他其他变量的值，而且也无法通过*p修改变量x的值。

const int *const p=null;④

int const* const p=null;⑤

const与引用

y是x的一个别名，由const修饰的y之后，只能通过对x操作来修改x的值，无法通过y来修改x的值。

两种写法对比：（权限限制）

const int x=3; int *y=&x;

x是一个常量，用一个可变的指针指向一个常量，则很有可能通过指针修改常量的值，计算机是不允许这种有风险的操作，所以这种写法是错误的。

int x=3;const int *y=&x;

x是一个变量，(可以看作，具有读写的权利)，用一个由const修饰的指针y指向下x，y只能指向x一个变量，(可以看作，const修饰下，y只有读的权利，没有写的权利了)然后可以直接用对x操作来修改x的值。但是*y就无法修改x的值。这种在计算机下是可以行的。用一个权限小的来限定权限大的。

const与define

#define X 3

const int x=3;

从效果上来讲是一样的，都是定义一个X值为3的常量。但是在编译的过程中，define由于是宏定义，就不再检查错误。而const在编译的时候就需要检查错误。

所以推荐使用const来定义一个常量。

const在函数中的使用

const的使用可以保证传入函数中变量，不会因为函数的误操作而修改原有值。

函数默认值和函数重载

函数参数默认值特性

有默认参数值的参数必须写在参数表的最右端。

void fun（int i,int j=0,int k=10);是正确的。

void fun（int i,int j=5,int k);是错误的。

声明的时候可以写参数默认值，定义的时候最建议不要写。

#include<iostream>
using namespace std;
void fun(int i,int j=10,int k=11){
cout<<i<<endl;
cout<<j<<endl;
cout<<k<<endl;
}
int main(){
fun(20);
cout<<"========"<<endl;
fun(20,30);
cout<<"========"<<endl;
fun(20,30,40);
return 0;

}

输出结果：20 10 11；20 30 11； 20 30 40

没有实参就用默认值，有实参就去覆盖默认值。

函数重载（提高效率）

在相同的作用域内，用同一函数名定义的多个函数，参数类型和参数个数不同。

遇到函数名称相同的情况，计算机通过函数名称加参数个数参数类型来判断是使用哪个函数。

内联函数

编译时将函数体代码和实参代替函数调用语句。内联函数只是一种编译方式。

关键字：inline。

为什么并不是所有的函数都使用内敛函数？虽然他效率高，运行速度快，但是是有条件的。

内联函数是建议性的，由编译器决定是不是采用内敛函数。

内联函数只能是逻辑简单，调用频繁的函数建议使用内联。

递归函数无法使用内敛方式。

练习：

        #include <iostream>
using namespace std;
/**
  *函数功能：返回a和b的最大值
  *a和b是两个整数
  */
int getMax(int a, int b)
{
    return a > b ? a : b;
}

/**
  * 函数功能：返回数组中的最大值
  * arr：整型数组
  * count：数组长度
  * 该函数是对上面函数的重载
  */
int getMax(arr,count)
{
    //定义一个变量并获取数组的第一个元素
    int temp=arr[0];
	for(int i = 1; i < count; i++)
	{
        //比较变量与下一个元素的大小
		if(temp<arr[i])
		{
            //如果数组中的元素比maxNum大，则获取数组中的值
			temp=arr[i];
		}	
	}
	return temp;
}
int main(void)
{
    //定义int数组并初始化
	int numArr[3] = {3, 8, 6}; 
    //自动调用int getMax(int a, int b)
	cout << getMax(3, 6) << endl;
    int count=3;
    //自动调用返回数组中最大值的函数返回数组中的最大值
	cout << getMax(numArr, count) << endl;
	return 0;
}
//自动调用int getMax(int a, int b)
cout << getMax(3, 6) << endl;
int count=3;
//自动调用返回数组中最大值的函数返回数组中的最大值
cout << getMax(numArr, count) << endl;
return 0;
}

    

错误原因：在对getMax（int a,int b）进行重载的时候，即getMax（arr，count）没有声明arr和count的类型。正确写法应该是：

int getMax(int *arr,int count)

内存管理

什么是内存管理？

内存的本质就是资源，内存是由操作系统掌控的。我们需要向os申请或者归还内存资源。

如何进行内存的申请和释放？

一个或者某一类型的内存申请与释放：

申请内存 new运算符 int *p=new int;

释放内存 delete运算符 delete p;

申请和释放块内存：

申请块内存：int *arr=new int[10];

释放块内存：delete []arr;

内存操作注意事项：

c语言：申请：malloc 释放 free

运算符配套使用，不要混搭。

申请内存有可能由于内存不够等原因申请失败。

申请内存的时候需要判断是否成功，释放内存需要设空指针。

释放内存注意事项

释放完内存以后，要将指针置为NULL；避免出现同一块内存被重复回收，计算机出现异常。

练习：

在堆中申请100个char类型的内存，拷贝Hello imooc字符串到分配的堆中的内存中,打印字符串,最后释放内存。

#include <string.h>
#include <iostream>
using namespace std;
int main(void)
{
//在堆中申请100个char类型的内存
char *str = new char[100];
//拷贝Hello C++字符串到分配的堆中的内存中
strcpy(str, "Hello imooc");
//打印字符串
cout<<str;
//释放内存
delete []str;
str=NULL;
return 0;
}

原文：https://www.cnblogs.com/yunxiaoqian/p/13937489.html