C++ Primer Plus 随记（第八章）

Posted 2021-05-07 lvliang2229

1.创建引用变量：

 int rat;

int & roatents=rat; //此式中&不是地址运算符，而是类型表示符，roatents是rat的别名,他们指向相同的值和内存单元，改变                                        //roatents的值，rat也会变。roatents是一个引用变量

int * prats=&rat; //prat是指针

//roatents、*prats可以和rat互换，&roatents，prats可和&rat互换。

//引用与指针的区别：在声明引用时将其初始化，指针可以先声明再赋值。二者用法也不同

2.将引用用作函数参数：

void  grumy(int &x);

int main(){ int t=20;  grumy( t ) ; .....} //调用grumy(int &x)时，使x成为 t 的别名。

3.交换两个变量时，能传递引用（使用原始数据）或传递指针（访问原始数据）来实现，但按值传递变量不能实现（函数交换的是原始变量的副本）。【函数声明分辨如下，主要:返回类型是void】

void swpar( int & a,int & b);//传递引用

void swpar( int * p,int * q); // 传递指针

void swpar( int  a,int   b);  //按值传递

4.当函数返回值是基本数值类型时，应采用按值传递，不要采用按引用传递（这种方式会改变原本的实参值），当数据类型比较大如是（结构或类）使，引用参数有用。

5.如果引用参数是const ,在下面两种情况编译器会生成临时变量：     （  double refcube(const double &ra) { ..... } ）

（1）实参类型正确，但不是左值

（2）实参类型不正确，但可以转化为正确类型。

引用参数声明为const时，可以避免函数修改数据，必要时生成临时变量

6.引用用于类对象：

#include "stdafx.h"
#include<iostream>
#include<string>
using namespace std;
string version1(const string & s1, const string & s2);
const string & version2(string & s1, const string &s2);
int main()
{
	string input;
	string copy;
	string result;
	cout << "Enter a string";
	getline(cin, input);
	copy = input;
	cout << input << endl;
	result = version1(input, "***");
	cout << "Your string enhanced: " << result << endl;
	cout << "Your original string: " << input << endl;
	result = version2(input, "###");
	cout << "Your string enhanced: " << result << endl;
	cout << "Your original string: " << input << endl; 
	//通过调用version2，返回的是引用变量s1,s1是input的别名，此时result=input,改变了输入参数，
	//version2的参数引用s1没有const的限定。可以修改。
	//version1的返回类型string的tempt，函数执行完后tempt不存在，tempt的内容复制到一个临时存
//储单元，在将该单元的内容复制到result
	//version1的参数是const的引用s1,s2,使用引用的效率更高，函数不需要创建新的string对象。
	return 0;
}
string version1(const string & s1, const string & s2)
{
	string tempt;
	tempt = s2 + s1 + s2;
	return tempt;
}
const string & version2(string & s1, const string &s2)
{
	s1 = s2 + s1 + s2;
	return s1;
}

7.派生对象可以使用基类的特性，如ofstream对象可以使用ostream类的方法。

 基类引用可以指向派生类对象：定义一个接受基类引用作为参数的函数，调用该函数时，可以将基类对象作为参数，也可将派生类对象作为参数。

8.设置函数的默认参数时，在函数原型中，参数必须从右向左添加默认值，

int harpo(int n, int m=4, int j=5); //当调用harpo(2) 时，n=2,int m=4, int j=5，；调用harpo()时，n默认为1

//调用形式harpo(2,  , 8)不合法，实参从左到右依次赋给形参，不能跳过。

int chico(int n, int m=4, int j); //不合法

9.函数重载的关键是函数的参数列表——称为函数特征标。（函数参数类型和数目）。使用重载函数（参数类型不同）时，默认参数不管用了。

匹配函数时，不区分const和非const.. 类型引用（int &）和类型(int )视为同一种特征标

返回类型不同时，特征标也必须不同。

long gronk (int n, float m);   

double grouk (int n, float m); //不许这种方式

double grouk (float n, float m);  //允许

10.函数模板，例，交换模板.

template <typename T>  //或 template <class T> 

void swap(T &a, T &b);

int main(){

int i=10; int j=50; swap(i,j);

double x=24.5; double y=81.7; swap(x,y);

}

template <typename T>

void swap(T &a, T &b){

T temp;

temp=a; a=b; b=temp;

}

11.重载模板：

template <typename T> 

void swap(T &a, T &b)；//原模板

template <typename T>

void swap(T *a,T *b, int n);//新模板

12.当参数是结构时，模板具体化：（job是一个结构）

template <typename T>

void swap(T &a, T &b)；

templte <> void swap<job>(job &j1, job &j2);

显示实例化：int x=6;   double y=9;

swap<double>(x,y);//强制为double的实例化，将x强制转换为double