C++笔记 03

一. new操作符

1. C++利用new操作符在堆区开辟数据
2. 堆区开辟数据，由程序员手动开辟，手动释放，释放利用操作符delete。
   语法： new 数据类型
   利用new创建的数据，会返回该数据对应的类型的指针
   举例：int *p=new int(10);

int *func()
{
	int *a=new int(10);
	return a;
}

/*
int main()
{
	int *p=func();
	cout<<*p<<endl;
	delete p; //利用delete释放堆区数据
......
}
*/

//堆区开辟数据
int main()
{
	int*arr=new int[10];
	for(int i=0;i<10;i++)
		{
		arr[i]=i+100;
		}
	for(int i=0;i<10;i++)
		{
		cout<<arr[i]<<endl;
		}
	delete[]arr;  //释放数组delete后加[]
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

二. 引用

1. 作用：给变量起别名
   语法：数据类型 &别名 = 原名
   注意事项：1）引用必须初始化 int &c ; (错误) int &c=b ; (正确）
   2）引用在初始化后，不可以改变

2. 引用做函数参数
   作用：函数传参时，可以利用引用的技术让形参修饰实参
   优点：可以简化指针修改实参
   示例：

//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;
}

//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);
	myswap02(&a,&b);
	myswap03(a,b);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

3. 引用做函数返回值
   作用：引用是可以作为函数的返回值存在的
   注意：不要返回局部变量引用
   用法：函数调用作为左值

//返回局部变量引用
int & test01()
{
	int a=10; //局部变量，存放在栈区
	return a;
}

//返回静态变量引用
int & test02()
{
	static int a=20; //静态变量，存放在全局区
	return a;
}

int main()
{
	//不能返回局部变量的引用
	int &ref=test01();
	cout<<"ref="<<ref<<endl; //第一次结果正确，是因为编译器做了保留
	cout<<"ref="<<ref<<endl; //第二次结果错误，因为a的内存已经释放
	cout<<"ref="<<ref<<endl; //之后都会错误

	//如果函数做左值，必须返回引用
	int &ref2=test02();
	cout<<"ref2="<<ref2<<endl; /*此时结果会一直正确，因为返回的是静态变量引用，
                            存放在全局区，而不再栈区*/
	cout<<"ref="<<ref<<endl;

	test02()=1000; /*相当于使a=1000，ref2是a的别名。如果函数的返回值是引用，
	                   这个函数调用可以作为左值*/
	cout<<"ref2="<<ref2<<endl;  //输出ref2=1000
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

4. 引用的本质
   引用的本质在C++内部实现是一个指针常量

//发现是引用，转换为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;
	func(a);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

（C++推荐用引用技术，因为语法方便，引用本质是指针常量，但是所有的指针操作编译器都帮我们做了。）

5. 常量引用
   作用：常量引用主要用来修饰形参，防止误操作
   在函数形参列表中，可以加const修饰形参，防止形参改变实参

// int &ref=10 ;(错误)引用本身需要一个合法的内存空间，因此这行错误
//加const就可以了，编译器优化代码，int temp=10;const int& ref=temp;
const int &ref =10;
//ref =100; (错误)加入const 后不可以修改变量

void showvalue (const int &v)
{
	//v+=10; (错误)
	cout<<v<<endl;
}

int main()
{
	int a=10;  //函数中利用常量引用防止误操作修改实参
	showvalue(a);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

三. 函数提高

1. 函数默认参数
   在C++中，函数的形参列表中的形参是可以有默认值的
   (如果我们自己传入数据，就用自己的数据，如果没有，那么用默认值)
   语法：返回值类型 函数名 （参数=默认值）{ }
   注意：1）如果某个位置参数有默认值，那么从这个位置往后，从左向右，必须都要有默认值。
   2）如果函数声明有默认值，函数实现的时候就不能有默认参数，反之也一样。

2. 函数占位参数
   C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置。
   语法：返回值类型 函数名 （数据类型）{ }

void func(int a,int)
{
	...
}

int main()
{
	func(10,10); //占位参数必须填补
}
void func(int a,int=10)  //占位参数也可以有默认参数
1
2
3
4
5
6
7
8
9
10

3. 函数重载
   作用：函数名可以相同，提高复用性
   函数重载满足条件（须都满足）：
   1）同一个作用域下（例如都在全局作用域下，而不是一个在全局作用域下，一个在主函数中）
   2）函数名称相同
   3）函数参数类型不同或者个数不同或顺序不同
   (注意：函数的返回值不可以作为函数重载的条件)

void func()  (正确)
void func(int a) (正确)
void func(double a) (正确)
void func(int a,double b) (正确)
void func (double a,int b) (正确)
int func(double a,int b)) (错误)
1
2
3
4
5
6

函数重载注意事项（“坑”）
1）引用作为重载条件
2）函数重载碰到函数默认参数

//函数重载注意事项

//1. 引用作为重载条件
void func(int &a)
{
	cout<<"func (int &a)调用"<<endl;
}

void func(const int &a)
{
	cout<<"func (const int &a)调用"<<endl;
}

//2.函数重载碰到函数默认参数
void func2(int a,int b=10)
{
	cout<<"func (int a,int b=10)调用"<<endl;
}

void func2(int a)
{
	cout<<"func (int a)调用"<<endl;
}

int main()
{
	int a=10;
	func(a);  //调用无const,该a可读可写
	func(10); //调用有const,因为const int &a=10合法，而int &a=10不合法

	func2(10); //错误，碰到默认参数，产生歧义，需要避免
	func(10,20); //可以
	... ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34