第8讲——函数探幽

前面的笔记都是行云流水,因为前面几章看过了,从这一讲开始,每一讲都是现学现做笔记的。

没人是天生的赢家,只有后天的loser。

由上一讲中的知识,我们了解到许多有关C++函数的知识,但需要学习的知识还很多。C++还提供许多新的函数特性,使之有别于C语言。

新特性包括内联函数、按引用传递变量、默认的参数值、函数重载(多态)以及模板函数。

这一讲中,我们将介绍C++在C语言基础上新增的特性,比前面各讲都多,这是我们进入(++)领域的重要一步。

【内联函数】

这是为提高程序运行速度所做的一项改进。

内联函数与常规函数的主要区别不在于编写方式,而在于C++编译器如何将它们组合到程序中。

要了解内联函数与常规函数之间的区别,必须深入到程序内部。

我们知道编译过程的最终产品是可执行程序——由一组机器语言指令组成。运行程序时,操作系统将这些指令载入到计算机内存中,因此每条指令都有特定的内存地址。计算机随后将逐步执行这些指令。有时(如有循环或分支语句时),将跳过一些指令,向前或向后跳到特定地址。常规函数调用也使程序调到另一个地址(函数的地址),并在函数结束时返回。

下面更详细地介绍这一过程的典型实现。

执行到函数调用指令时,程序将在函数调用后立即存储该指令的内存地址,并将函数参数复制到堆栈(为此保留的内存块),跳到标记函数起点的内存单元,执行函数代码(也许还需将返回值放入到寄存器中),然后跳回到地址被保存的指令处(这与阅读文章时停下来看脚注,并在阅读完脚注后返回到以前阅读的地方类似)。来回跳跃位置意味着以前使用函数时,需要一定的开销。

此时,内联函数出现了,它提供了另一种选择。内联函数的编译代码与其他程序代码“内联”起来了。也就是说,编译器将使用相应的函数代码替换函数调用。对于内联代码,程序无需跳到另一个位置处执行代码,再跳回来。因此,内联函数的运行速度比常规函数稍快,但代价是需要占用更多内存。如果程序在10个不同的地方调用同一个内联函数,则该程序将包含该函数代码的10个副本。

当然,我们不能盲目地使用内联函数,相反,我们应有选择地使用内联函数。

如果执行函数代码的时间比处理函数调用机制的时间长,则节省的时间将只占整个过程的很小一部分。如果代码执行时间很短,则内联调用就可以节省非内联调用使用的大部分时间。另一方面,由于这个过程相当快,因此尽管节省了该过程的大部分时间,但节省的时间绝对值并不大,除非该函数经常被调用。

上面说了一堆理论知识,那我们如何使用这项特性呢??

  • 在函数定义前加上关键字inline

除此之外,我们通常省略原型,将整个定义(即函数头和所有函数代码)放在本应提供原型的地方。

  • 知识点:内联函数不能递归

下面是一个计算参数的平方的程序:

#include<iostream>
//一个内联函数定义
inline double square(double x)
{
	return x*x;
}

int main()
{
	using namespace std;
	double a = square(5.0);
	cout<<"a = "<<a<<endl;
}

我们注意到上述程序中整个内联函数的定义只占用了几行,如果函数定义占用多行(假定没有使用冗长的标识符),则将其作为内联函数就不太合适。

上述程序亦表明,内联函数和常规函数一样,也是按值来传递参数的。

如果参数为表达式(如4.5+7.5),则函数将传递表达式的值(为12)。这使得C++的内联功能远远胜过C语言的宏定义。

【默认参数】

这将又是C++的另一项新内容,让我们慢慢欣赏吧。

默认参数——当函数调用中省略了实参时自动使用的一个值。

上面是书本的解释,我的看法如下:

假设我们创建一个函数如下:

void wow(int n)

如若我们要调用这个函数,我们应该在调用函数中这样调用:wow(2);或int a=2;wow(a);,调用语句的本质是实参不能为空。而如果我们设置成n有默认值为1:

void wow(int n = 1)

哈哈,这时我们可以在调用函数中这样调用:wow();,此时实参为空,但由于形参n有默认值为1,那么此调用语句等价于:wow(1); 。当然如果我们调用语句为:wow(2);,那么形参n就是2,而不是1。

好了,我的讲解完了,是不是仿佛知道了默认参数的用处啊。

  • 我们只能通过函数原型设置参数的默认值,方法是将值赋给原型中的参数。这是由于编译器通过查看原型来了解函数所使用的参数数目,因此函数原型也必须将可能的默认参数告知程序。同时,只需要函数原型指定默认值,而函数定义与没有默认参数时完全相同。

每每学习一个知识点,总有它的要求:对于带参数列表的函数,必须从右向左添加默认值。也就是说,要为某个参数设置默认值,则必须为它右边的所有参数提供默认值。

下面我们举几个例子:

int chico(int n, int m = 6, int j);		//错误
int harpo(int n, int m = 4, int j = 5);
//harpo()原型允许调用该函数时提供1个、2个或3个参数:
beeps = harpo(2);			//same as harpo(2,4,5);
beeps = harpo(1,8);			//same as harpo(1,8,5);
beeps = harpo(8,7,6); 		//没有使用默认参数

除此,我们还要知道实参按从左到右的顺序依次被赋给相应的形参,而不能跳过任何参数。下面的调用就是一个反例:

beeps = harpo(3, ,8);		//错误,doesn‘t set m to 4

看到这,你可能吐槽默认参数的作用甚微,是的,它并非编程方面的重大突破,它只是提供了一种便捷的方式。而且,在设计类时我们将发现,通过使用默认参数,可以减少要定义的析构函数、方法以及方法重载的数量。

【函数重载】

在了解函数重载之前,我们先看一下函数多态。

函数多态是C++在C语言的基础上新增的功能。

学完了默认参数,我们知道它让我们能够使用不同数目的参数调用同一个函数,而函数多态(函数重载)让我们能够使用多个同名的函数。

术语“多态”:指的是有多种形式,因此函数多态允许函数可以有多种形式。

类似地,术语“函数重载”:指的是可以有多个同名的函数,因此对名称进行了重载。

这两个术语指的是同一回事,但我们通常使用函数重载。

简而言之,上面一大堆废话就是说:我们可以通过函数重载设计一系列同名的函数。

有多个同名的函数又怎么样??有什么用吗?

当然有用啦!!

这些同名函数使用了不同的参数列表,但它们却完成相同的工作。

所以函数重载的关键是函数的参数列表——也称为函数特征标。

两个函数的特征标相同:参数数目相同、参数类型相同、参数的排列顺序相同。

C++允许定义名称相同的函数,条件是它们的特征标不同。

  • 请记住:是特征标,而不是函数类型使得可以对函数重载。其实,这个我们仔细想一想就明白了,试想,若两个同名函数的特征标相同,那么我们调用语句与这两个函数都匹配,编译器就不知道调用哪个了,所以特征标才是函数重载的关键。

关于重载的几个注意点。

double cube(double x);
double cube(double &x);

这两个函数的特征标看上去不同,然而它们不能共存。因为如果有调用语句:cube(a);,参数a与double x原型和double &a原型都匹配,因此为避免这种混乱,编译器将把类型引用和类型本身视为同一个特征标。

/*	匹配函数时,并不区分const和非const变量	*/
void dribble(char *bits);		//用于常规指针
void dribble(const char *bits);	//用于const指针
//下面两个函数不能重载
void dabble(char *bits);
void drivel(const char *bits);
//下面给出了各种函数调用对应的原型:
const char p1[20] = "How‘s the weather?";
char p2[20] = "How‘s business?";
dribble(p1);	//dribble(const char *);
dribble(p2);	//dribble(char *);
dabble(p1);		//no match
dabble(p2);		//dabble(char *)
drivel(p1);		//drivel(const char *)
drivel(p2); 	//drivel(const char *)

dribble()函数有两个原型,一个用于const指针,另一个用于常规指针,编译器将根据实参是否为const来决定使用哪个类型。dabble()函数只与带非const参数的调用匹配,而drivel()函数可以与带const或非const参数的调用匹配,只因为将非const值赋给const变量是合法的,但反之则是非法的。

我们何时使用函数重载呢??

  • 仅当函数基本上执行相同的任务,但使用不同形式的数据时。

【函数模板】

这又是C++新增的一项特性。

函数模板是通用的函数描述,也就是说,它们使用泛型来定义函数,其中的泛型可用具体的类型(如int或double)替换。

通过将类型作为参数传递给模板,可使编译器生成该类型的函数。

由于模板允许以泛型(而不是具体类型)的方式编写程序,因此有时也被称为通用编程。

由于类型是用参数表示的,因此模板特性有时也被称为参数化类型。

我承认这些都是废话。。。

下面我们来学习为何需要函数模板以及其工作原理。

看下面这个交换两个int值的程序:

#include<iostream>
using namespace std;

void swap(int *a, int *b)
{
	int t;  t = *a;	 *a = *b;	*b = t;
}
int main()
{
	int n1 = 3, n2 = 4;
	swap(n1, n2);
}

那么,如果我们要交换两个double值,我们会想到复制swap函数的代码,并用double替换所有的int。同理,如果需要交换两个char值,我们可以再次使用同样的技术。显然,进行这种修改将浪费宝贵的时间,且容易出错。这时,我们在想有没有什么好的办法完成这项任务呢?

当然有咯!!C++的函数模板功能能自动完成这一过程,可以节省时间,而且更可靠。

函数模板允许以任意类型的方式来定义函数。

例如,我们可以建立一个交换模板:

template <typename T>	//将类型命名为T,关键字typename可以用class代替
void swap(T *a, T *b)
{
	T t;  t = *a;	 *a = *b;	*b = t;
}

我们要知道,模板并不创建任何函数,而只是告诉编译器如何定义函数。

需要交换int的函数时,编译器将按模板模式创建这样的函数,并用int代替T。同样,需要交换double的函数时,编译器将按模板模式创建这样的函数,并用double代替T。

更常见的情形是,将模板放在头文件中,并在需要使用模板的文件中包含头文件。

当我们需要多个对不同类型使用同一种算法的函数时,可使用模板。

但并非所有的类型都使用相同的算法,这是,我们可以像重载常规函数定义那样重载模板定义。

和常规重载一样,被重载的模板的函数特征标必须不同。如下面的程序:

template <typename T>
void swap(T *a, T *b);

template <typename T>
void swap(T a[], T b[], int n); //并非所有的模板参数都必须是模板参数类型(T)

template <typename T>
void swap(T *a, T *b)
{
	T t;  t = *a;	 *a = *b;	*b = t;
}

template <typename T>
void swap(T a[], T b[], int n)
{
	T t;
	for(int i = 0; i < n; i++)
	{
		t = a[i];
		a[i] = b[i];
		b[i] = t;
	}
}

上述程序中新增了一个交换模板,用于交换两个数组中的元素。原来的模板的特征标为(T &, T &),而新模板的特征标为(T[], T[], int)。

注意,在后一个模板中,最后一个参数的类型为具体类型(int),而不是泛型。并非所有的模板参数都必须是模板参数类型。

看到了模板函数的好处,它的局限性也比较显著。

假设有如下模板函数:

void f(T a, T b)
{
	...
}

函数体内总会执行一些操作,这是不可否认的。假如,函数体内定义了赋值,但如果T为数组,这个模板函数就没用;再比如,函数体内定义了<,但如果T为结构,这个模板也没用。此外,还有好多好多。

总之,编写的模板函数很可能无法处理某些类型。

但我们可以想办法解决这个困难。例如,将两个包含位置坐标的结构相加是有意义的,虽然没有为结构定义运算符+。

此时,我们有两种解决方案:①C++允许我们重载运算符+,以便能够将其用于特定的结构或类,这样使用运算符+的模板便可处理重载了运算符+的结构;②为特定类型提供具体化的模板定义。

下面我们将来介绍第二种解决方案,因为第一种解决方案等我们学完运算符重载就会了啊!

我们来看这样一个结构:

struct job{
	char name[20];
	double salary;
	int floor;
};

我们要交换两个这种结构的内容可以使用上面的第一种模板,因为C++允许将一个结构赋给另一个结构。

然而,如果我们只想交换salary成员,其他成员不做交换,那么就需要使用不同的代码,但swap()的参数将保持不变(两个job结构的引用),因此无法使用模板重载来提供其他的代码。

然而,可以提供一个具体化函数定义(称为显示具体化),这个函数包含所需的代码。当编译器找到与函数调用匹配的具体化定义时,将使用该定义,而不再寻找模板。

温故而知新

1.哪种函数适合定义为内联函数

短小的,执行速度快的,占用内存小,非递归的。

2.假如song()函数的原型如下:

void song(const char* name, int times);

a.如何修改原型,使times的默认值为1?

b.函数定义需要做哪些修改?

c.能否为name提供默认值“O.My Papa”?

答:

a。 修改成:void song(const char*name,int times=1);

b。函数定义无需修改

c。可以,但前提是为times提供默认值,且在调用时,应符合带默认参数的函数的调用方式。函数原型如改成:

void song(const char*name="O.My Papa", int times =1);

答案没有加const,但我觉得应该加上吧。

3.编写iquote()的重载版本——显示其用双引号括起的参数。编写3个版本:一个用于int参数,一个用于double参数,一个用于string参数。

答:

void iquote(int a)
{
    cout<<"\""<<a<<"\‘"<<endl;
}

void iquote(double a)
{
    cout<<"\""<<a<<"\""<<endl;
}

void iquote(string a)
{
    cout<<"\""<<a<<"\""<<endl;
}

4.下面是一个结构模板:

struct box{
	char maker[40];
	float height;
	float width;
	float length;
	float volume;
};

a.请编写一个函数,它将box结构的引用作为形参,并显示每个成员的值。

b.请编写一个函数,它将box结构的引用作为形参,并将volume成员的值设为其他3边的乘积。

答:

//a
void abc_1(const box& a)
{
    cout<<a.maker<<endl;
    cout<<a.height<<endl;
    cout<<a.width<<endl;
    cout<<a.length<<endl;
    cout<<a.volume<<endl;
}

//b
void abc_2(box& a)
{
    a.volume=a.height*a.width*a.length;
}

5.为让函数fill()和show()使用引用参数,需要对程序清单7.15做哪些修改?

答:

//原型修改为:
void fill(std::array<double,Seasons>&);
void show(std::array<double,Seasons>&);

//函数定义修改为:
void fill(std::array<double,Seasons>&pa)
{
    using namespace std;
    for (int i = 0; i < Seasons; i++){
        cout<< "Enter "<< Snames[i]<<" expenses: ";
        cin>>pa[i];
    }
}
void show(std::array<double, Seasons> &da)
{
    using namespace std;
    double total = 0.0;
    cout<<"\nEXPENSES\n";
    for (int i = 0; i < Seasons; i++){
        cout<<Snames[i]<<": $"<<da[i]<<endl;
        total += da[i];
    }
    cout<<"Total Expenses: $"<<total<<endl;
}

//函数调用改为:
fill(expenses);
show(expenses);

6.指出下面每个目标是否可以使用默认参数或函数重载完成,或者这两种方法都无法完成,并提供合适的原型。

a. mass(density,volume)返回密度为density、体积为volume的物体的质量,而mass(density)返回密度为density、体积为1.0立法米的物体的质量。这些值的类型都为double。

答:

可以用函数重载完成,也可以用默认函数完成。

默认函数如下:

double mass(double a, double b=1);

函数重载如下:

double mass(double a,double b);

double mass(double a);

b. repeat(10,"I‘m OK")将指定的字符串显示10次,而repeat("But you‘re kind of stupid")将指定的字符串显示5次。

答:

只能用函数重载完成,不能用默认函数,原型为:

void repeat(int,string);

void repeat(string);

c. average(3,6)返回两个int参数的平均值(int类型),而average(3.0,6.0)返回两个double值的平均值(double类型)。

答:

只能用函数重载完成,原型为:

int average(int,int);

double average(double,double);

d. mangle("I‘m glad to meet you")根据是将值赋给char变量还是char*变量,分别返回字符1和指向字符串“I‘m glad to meet you”的指针。

答:

两种方法都无法完成。

7.编写返回两个参数中较大值的函数模板。

答:

template<class xx>xx bigger(xx a,xx b)
{
    xx c=(a>b)?a:b;
    return c;
}

8.给定复习题6的模板和复习题4的box结构,提供一个模板具体化,它接受两个box参数,并返回体积较大的一个。

答:

template<>box mass(box a,box b){
    return (a.volume>b.volume)?a:b;
}

9.在下述代码(假定这些代码是一个完整程序的一部分)中,v1、v2、v3、v4和v5分别是哪种类型?

int g(int x);
....
float m = 5.5f;
float &rm = m;
decltype(m)v1 = m;
decltype(rm)v2 = m;
decltype((m)) v3 = m;
decltype(g(100))v4;
decltype(2.0*m)v5;

答:v1为float、v2为float&,v3为float(错,为float&,核对表的第三步),v4为g(100)这个函数的返回值的类型int(做题的时候没有注意第一行)(核对表的第二步),v5为double(核对表的第一步)。

时间: 2024-10-05 04:58:19

第8讲——函数探幽的相关文章

函数探幽

函数探幽 内联函数 c++为提高程序运行速度的一项改进. 非内联函数在调用时来回跳跃并记录产生了一定的开销. 内联函数编译器将使用相应的函数代码替换函数调用.无需跳到另一个位置去执行代码. 内联函数运行速度比常规函数稍快,但代价是占用更多内存. 如果程序在10个不同的地方调用同一个内联函数,该程序将包含该函数代码的10个副本. 如果执行函数代码时间比函数调用时间短,则应该使用内联函数. 要使用内联函数需要在函数声明和定义前加上inline关键字. 通常的做法是省略声明,直接定义. 有些函数即使声

C++ primer plus读书笔记——第8章 函数探幽

第8章 函数探幽 1. 对于内联函数,编译器将使用相应的函数代码替换函数调用,程序无需跳到一个位置执行代码,再调回来.因此,内联函数的运行速度比常规函数稍快,但代价是需要占用更多内存. 2. 要使用内联函数,需要在: 函数声明前加上关键字inline; 函数定义前加上关键字inline; 3. 程序员请求将函数作为内联函数时,编译器不一定会满足这种需求.它可能认为该函数过大或注意到函数调用了自己(内联函数不能递归). 4. 必须在声明引用变量时进行初始化 int rat = 101; int &

第7讲——函数初步

我们知道,C++自带了一个包含函数的大型库(标准ANSI库加上多个C++类),但这并不能满足我们的需求,我们需要编写自己的函数.但我们在编写函数时为了提高编程效率,可更深入地学习STL和BOOST C++提供的功能. 我们先学习一下库函数,它是已经定义和编译好的函数,同时可以使用标准库头文件提供其原型,因此只需正确地调用这种函数即可.例如,标准C库中有一个strlen()函数,相关的标准头文件cstring包含了strlen()和其他一些与字符串相关的函数的原型.这些预备工作使程序员能够在程序中

0607pm克隆&amp;引用类&amp;加载类&amp;面向对象串讲&amp;函数重载

克隆class Ren{ public $name; public $sex; function __construct($n,$s) { $this->name=$n; $this->sex=$s; } function __clone()//改变克隆的对象内容 { $this->name="李思思";//this代表复本对象 $that->name="李思思";//that代表原本的,后来废弃了 }}$r=new Ren("张丹

C++Premer Plus学习(五)&mdash;&mdash;函数探幽

一.内联函数 1.优点: 内联函数就是比较省资源,然后一般就是将简短,使用频率高的函数作为内联函数会比较合适. 2.一个demo #include "stdafx.h" #include<iostream> using namespace std; inline double Square(double x) { return x*x; } int _tmain(int argc, _TCHAR* argv[]) { int a = 16; cout << Sq

第八章:函数探幽

8.1题 1 #include<iostream> 2 void silly(const char * s,int n = 0); 3 int main() 4 { 5 char *pointer = "lala"; 6 silly("hello?"); 7 for(int i = 0; i < 5; i++) 8 silly(pointer,i); 9 } 10 void silly(const char * s,int n) 11 { 12 s

函数探幽--引用变量

引用是已定义的变量的别名(另一个名称).如果将twain作为clement作为变量的引用,则可以交替使用twain和Clemente来表示该变量. 引用变量的主要用途是用作函数的形参.通过将引用变量用作参数,函数将使用原始数据而不是其副本. 创建引用变量 要将rodents作为rats变量的别名 int rats; int & rodents = rats; 这里的&不是地址运算符,而是类型标识符的一部分. 上述引用声明允许 rats 与 rodents 互换--他们指向相同的值和内存单元

从大数据菜鸟走上大师的历程 第二讲:函数定义,流程控制,异常处理

Scala 第二讲 函数定义,流程控制,异常处理 For 循环  for(左边为单个对象obj  <-  右边为对象集合objs ) for 循环里把右边的对象赋给左边 现在正是学习大数据的最好机遇,不花一分钱就可以成为大数据高手,实现年薪50万的梦想. 王家林的第一个中国梦:免费为全社会培养100万名优秀的大数据从业人员! 如果您有兴趣请点击这个链接进入大数据的学习 http://blog.sina.com.cn/s/blog_8fbd39ee0102vto3.html 如果您确实感觉视频教程

循环面前疑无路,柳暗花败又函数

今天,我是陷入了懵逼的死循环. 面对着无穷循环题,我的内心,是崩溃的. 几天前的for循环终于懂了,可是多重循环又把我懵了. 一道道用程序编*号,你们这些题,为何如此皮? 堪堪刷了一道,提交一看,妈耶!你们是否忒快了吧? 我我我--气煞我也! 我就不信追不上! 拍了拍旁边老铁,某某题你会不会?不会?你叫学长过来. 一番经验传授(带着似乎些许嘲讽)后,可算是会了. -- 下午,本以为能"开心"的刷题.同学们,我们现在讲函数. What!你在逗我!这么快就新课了!歪咦!妈耶!(凑字数) 听