C++小白课本练习2

对引用进行初始化示例

#include<iostream>
using namespace std;
//T表示类型，CT表示常量类型
//T&表示T类型的引用
//CT&表示类型T的常引用。
//程序以整型类型为例，列出了变量、变量引用、常变量以及常引用之间的各种初始化情况
//大多数都是允许的，只有最后两种情况，需要通过强制类型转换才能实现初始化。
void show() {
    
    
	const int cInt = 30;
	int oneInt = 50;
	int &ref = oneInt;	//T&<-T
	const int &rc1 = cInt;//CT&<--CT,CT&表示类型T的常引用
	const int &rc2 = oneInt;//CT&<-t
	const int &rc3 = ref;//CT&<-T&
	int dInt = ref;//T<--T&
	int eInt = cInt;//T<--CT,CT表示常量类型
	int fInt = rc1;//T<--CT&
	const int gInt = oneInt;//CT《--T
	int &ref1 = ref;//T&《--T&
	const int hInt = ref;//CT<--T&
	const int JInt = cInt;//CT<<-CT
	const int &mInt = rc1;//CT&<--CT&I
	const int Nint = rc2;//CT<--CT&
	cout << "OK" << endl;
	int &r2 = (int &)rc1;//T&<--CT&强制类型转换
	int &r3 = (int &)cInt;//T&<--CT强制类型转换

}
int main() {
    
    
	show();
}

}

不同的参数传递方式

#include <iostream>
using namespace std;
void SwapValue(int a, int b)
{
    
    
	int tmp;
	tmp = a;
	a = b;
	b = tmp;
	cout << "在SwapValue()函数中：\t\ta=" << a << ",b=" << b << endl;
	return;
}
void SwapRef(int & a, int &b) //a，b值互换
{
    
    
	int tmp;
	tmp = a;
	a = b;
	b = tmp;
	cout << "在SwapRef()函数中：\t\ta=" << a << ",b=" << b << endl;
	return;

}
int main() {
    
    
	int a = 10, b = 20;
	cout << "数据交换前：\t\ta=" << a << ",b" << b << endl;
	SwapValue(a, b);
	cout << "调用SwapVal()后：\t\ta=" << a << ",b=" << b << endl;
	a = 10; b = 20;
	SwapRef(a, b);
	cout << "调用SwapRef()后：\t\ta=" << a << ",b=" << b << endl;
	return 0;
}
//函数SwapVlue()的形参是两个整型变量，SwapRef()的形参是两个引用。

课本测试7引用作为函数返回值

#include <iostream>
using namespace std;
int oneX = 10;
int oneY = 20;
int & refValue(int & x) {
    
    
	return x;
}
int main()
{
    
    
	refValue(oneX) = 30;//返回值是引用，可以作为左值使用
	cout << "oneX=" << oneX << endl; //输出oneX=30
	refValue(oneY) = 40; //返回值是引用的函数调用表达式，可以作为左值使用
	cout<< "oneY=" << oneY << endl; //输出oneY=40
	return 0;
}

课本测试8常量说明示例.cpp

#include <iostream>
using namespace std;
int main()
{
    
    
	int a1 = 3; //普通变量，a1=5是正确的
	const int a2 = a1; //数据时常量的，a2=5是错误的
	int *a3 = &a1;//普通指针指向普通变量，*a3=6是正确的
	const int * a4 = &a1;//数据时常量的,普通指针*a4=5shi1cuowu1d1
	int * const a5 = &a1;//指针是常量的，不能修改指针，但*a5=10是正确的
	int const * const a6 = &a1;//数据时常量的，指针也是常量的
	const int * const a7 = &a1;//数据时常量的，指针也是常量的
	return 0;
}
//在声明const int a2中，const 修饰的是 int ，即a2表示一个常量，这个常量不会改变，所以不能写类似 a2=5 这样的语句。
//在声明 const int * a4中，const 修饰的是int 说明a4是指向常量的指针，不能通过指针a4修改指向的内容，
//在声明 int * const a5 中，const修饰的是* 说明这是一个常量指针，
//这个指针只能指向初始化时指向的地址，不能再指向其他地址，即不能改变它的指向

课本测试9函数的重载.cpp

#include <iostream>
using namespace std;

//返回两个int型数中的较大者
int biggerInt(int x, int y) {
    
    
	if (x > y)return x;
	else return y;
}

//返回两个float型数中的较大者
float biggerFloat(float x, float y) {
    
    
	if (x > y)return x;
	else return y;
}

//返回两个double型较大者
double biggerDouble(double x, double y) {
    
    
	if (x > y)return x;
	else return y;
}
int main() {
    
    
	//调用函数时进行有必要的类型提升
	int xI = 10, yI = 20;
	float xF = 30, yF = 40;
	double xD = 50, yD = 60;
	cout << biggerDouble(xI, yF) << endl;

}