2.4 函数

函数用于创建C++程序的模块。C++函数分两种:有返回值的和没有返回值的。

2.4.1 使用有返回值的函数

有返回值的的函数将生成一个值,而这个值可赋给变量或在其他表达式中使用。例如,标准C/C++库包含一个名为sqrt()的函数,它返回平方根。假设要计算6.25的平方根,并将这个值赋给变量x,则可以使用下面的语句:

x = sqrt (6.25); // returns the valua 2.5 and assigns it to x 

表达式sqrt(6.25)将调用sqrt()函数。表达式sqrt(6.25)被称为函数调用,被调用的函数叫做被调用函数(called function),包含函数调用的函数叫做调用函数(calling function)

圆括号中的值(这里为6.25)是发送给函数的信息,这被称为传递给函数。以这种方式发送给函数的值叫做参数。函数sqrt()得到的结果为2.5,并将这个值发送给调用函数;发送回去的值叫做函数的返回值(return value)。可以这么认为,函数执行完毕后,语句中的函数调用部分将被替换为返回的值。因此,这个例子将返回值赋给变量x。简而言之,参数是发送给函数的信息,返回值是从函数中发送回去的值。

在使用函数之前,C++编译器必须知道函数的参数类犁和返回值类型。如果缺少这些信息,编译器将不知道如何解释返回值。C++提供这种信息的方式是使用函数原型语句。

C++程序应当为程序中使用的每个函数提供原型。函数原型之于函数就像变量声明之于变量——指出涉及的类型。sqrt()的函数原型像这样:

double sqrt(double) //function prototype 

第一个double意味着sqrt()将返回一个double值。括号中的double意味着sqrt()需要一个double参数。原型结尾的分号表明它是一条语句,这使得它是一个原型,而不是函数头。如果省略分号,编译器将把这行代码解释为一个函数头,并要求接着提供定义该函数的函数体。

在程序中使用sqrt()时,也必须提供原型。可以用两种方法来实现:

第二种方法更好,因为头文件更有可能使原型正确。

不要混淆函数原型和函数定义。原型只描述函数接口。也就是说,它描述的是发送给函数的信息和返回的信息。而定义中包含了函数的代码,如计算平方根的代码。C和C++将库函数的这两项特性(原型和定义)分开了。库文件中包含了函数的编译代码,而头文件中则包含了原型。

应在首次使用函数之前提供其原型。通常的做法是把原型放到main()函数定义的前面。程序清单2.4演示了库函数sqrt()的用法,它通过包含cmath文件来提供该函数的原型:

程序清单2.4 sqrt.cpp

// sqrt.cpp -- using the sqrt() function

#include <iostream>
#include <cmath>    // or math.h

int main()
{
    using namespace std;
   
    double area;
    cout << "Enter the floor area, in square feet, of your home: ";
    cin >> area;
    double side;
    side = sqrt(area);
    cout << "That's the equivalent of a square " << side 
         << " feet to the side." << endl;
    cout << "How fascinating!" << endl;
	cin.get();
	cin.get();
    return 0;
}

下面是该程序的运行情况:

Enter the floor area, in square feet, of your home: 1536 
That's the equivalent of a square 39.1918 feet to the side.
How fascinating! 

C++允许在程序的任何地方声明新变量,因此sqrt.cpp在要使用side时才声明它。C++还允许在创建变量时对它进行赋值,因此也可以这样做:

double side = sqr(area); 

这个过程叫做初始化(initialization)

2.4.2函数变体

有些函数需要多项信息。这些函数使用多个参数,参数间用逗号分开。例如,数学函数pow()接受两个参数,返回值为以第一个参数为底,第二个参数为指数的幂,该函数的原型如下:

double pow(double,double); //prototype of a function with two arguments 

要计算5的8次方,可以这样使用该函数:

answer=pow(5.0, 8.0); //function call with a list of arguments 

另外一些函数不接受任何参数。例如,有一个C库(与cstdlib或stdlib.h头文件相关的库)包含一个rand()函数,该函数不接受任何参数,并返回一个随机整数。该函数的原型如下:

int rand(void); //prototype of a function that takes no arguments 

关键字void明确指出,该函数不接受任何参数。如果省略void,让括号为空,则C++将其解释为一个不接受任何参数的隐式声明。可以这样使用该函数:

myGuess=rand(); //function call with no arguments 

还有一些函数没有返回值。例如,假设编写了一个函数,它按美元、美分格式显示数字。当向它传递参数23.5,它将在屏幕上显示$23.50。由于这个函数把值发送给屏幕,而不是调用程序,因此不需要返回值。可以在原型中使用关键字void来指定返回类型,以指出函数没有返回值:

void bucks(double); //prototype for function with no return valua

由于它不返回值,因此不能将该函数调用放在赋值语句或其他表达式中。相反,应使用一条纯粹的函数调用语句:

bucks(1234.56); //function call, no return value

在有些语言中,有返回值的函数被称为函数(function);没有返回值的函数被称为过程(procedure)子程序(subroutine)。但C++与C一样,这两种变体都被称为函数。

2.4.3用户定义的函数

每个C++程序都必须有一个main()函数,用户必须对它进行定义。假设需要添加另一个用户定义的函数。和库函数一样,也可以通过函数名来调用用户定义的函数。对于库函数,在使用之前必须提供其原型,通常把原型放到main()定义之前。

现在必须提供新函数的源代码。最简单的方法是,将代码放在main()的后面。程序清单2.5演示了这些元素。

程序清单2.5 ourfunc.cpp

// ourfunc.cpp -- defining your own function 
#include <iostream>
void simon(int); // function prototype for simon()

int main()
{
	using namespace std;
	
	simon(3); // call the simon() function 
	cout << "选择一个整数: "; int count;
	cin >> count;
	simon(count); // call it again
	cout << "完成!" << endl;
	cin.get();
	cin.get(); 
	return 0; 
}

void simon(int n) // define the simon() function
{
	using namespace std; 
	cout << "Simon says touch your toes " << n << " times." << endl;
} // void functions don't need return statements 

main()函数两次调用simon()函数,一次的参数为3,另一次的参数为变量count。在这两次调用之间,用户输入一个整数,用来设置count的值。这个例子没有在cout提示消息中使用换行符。这样将导致用户输入与提示出现在同一行中。下面是运行情况:

Simon says touch your toes3 times.
Pick an integer: 512
Simon says touch your toes 512 times.
Done! 

1.函数格式

在程序清单2.5中,simon()函数的定义与main()的定义采用的格式相同。首先,有一个函数头;然后是花括号中的函数体。可以把函数的格式统一为如下的情形:

type functionname(argumentlist) 
{
    statements
}

定义simon()的源代码位于main()的后面。C++不允许将函数定义嵌套在另一个函数定义中。每个函数定义都是独立的,所有函数的创建都是平等的。

2.函数头

在程序清单2.5中,simon()函数的函数头如下:

void simon(int n)

开头的void表明simon()没有返回值。因此,第一个函数调用方式如下:

simon(3); // ok for void functions

括号中的int表明,使用simon()时,应提供一个int参数。n是一个新的变量,函数调用时传递的值将被赋给它。因此,下面的函数调用将3赋给simon()函数头中定义的变最n。当函数体中的cout语句使用n时,将使用函数调用时传递的值。这就是为什么simon (3)在输出中显示3的原因所在。在示例运行中,函数调用simon(count)导致函数显示512,因为这正是赋给count的值。简而言之,simon( )的函数头表明,该函数接受一个int参数,不返回任何值。

对于main()的函数,开头的int表明,main()返回一个整数值:空括号(其中可以包含void)表明,main()没有参数。对于有返回值的函数,应使用关键字return来提供返回值,并结束函数。这就是为什么要在main()结尾使用下述语句的原因:

return 0;

那这个值返回到哪里了呢?答案是,可以将计算机操作系统(如UNIX或Windows)看作调用程序。因此,main()的返回值并不是返回给程序的其他部分,而是返回给操作系统。很多操作系统都可以使用程序的返回值。例如,UNIX外壳脚本和Windows命令行批处理文件都被设计成运行程序,并测试它们的返回值(通常叫做退出值)。通常的约定是,退出值为0则意味着程序运行成功,为非零则意味着存在问题。因此,如果C++程序无法打开文件,可以将它设计为返回一个非零值。然后,便可以设计一个外壳脚本或批处理文件来运行该程序,如果该程序发出指示失败的消息,则采取其他措施。

2.4.4用户定义的有返回值的函数

下面编写一个使用返回语句的函数。在函数头中指出返回类型,在函数体结尾处使用return。可以用这种形式为在英国观光的人解决重量的问题。在英国,很多浴室都以英石(stone)为单位,不像美国以磅或公斤为单位。一英石等于14磅,程序清单2.6使用一个函数来完成这样的转换。

程序清单2.6 convert.cpp

// convert.cpp -- converts stone to pounds
#include <iostream>
int stonetolb(int);     // function prototype
int main()
{
    using namespace std;
    int stone;
    cout << "Enter the weight in stone: ";
    cin >> stone;
    int pounds = stonetolb(stone);
    cout << stone << " stone = ";
    cout << pounds << " pounds." << endl;
	cin.get();
    cin.get();
    return 0;
}

int stonetolb(int sts)
{
     return 14 * sts;
}

下面是该程序的运行情况:

Enter the weight in stone:15 
15 stone = 210 pounds. 

在main()中,程序使用cin来给整型变量stone提供一个值。这个值被作为参数传递给stonetolb()函数,在该函数中,这个值被赋给变量sts。然后,stonetolb()用关键字return将14*sts返回给main()。这表明return后面并非一定得跟一个简单的数字。这里通过使用较为复杂的表达式,避免了创建一个新变量,将结果赋给该变量,然后将它返回。程序将计算表达式的值(这里为210),并将其返回。如果返回表达式的值很麻烦,可以采取更复杂的方式:

int stonetolb(int sts) 
{
    int pounds = 14 * sts;
    return pounds;
}

这两个版本返回的结果相同,但第二个版本更容易理解和修改,因为它将计算和返回分开了。通常,在可以使用一个简单常量的地方,都可以使用一个返回值类型与该常量相同的函数。例如,stonetolb()返回一个int值,这意味着可以以下面的方式使用该函数:

int aunt = stonetolb(20); 
int aunts = aunt+stonetolb(10);
cout << "Ferdie weighs" << stonetolb(16) << "pounds" << endl; 

在上述任何一种情况下,程序都将计算返回值,然后在语句中使用这个值。

这些例子表明,函数原型描述了函数接口,即函数如何与程序的其他部分交互。参数列表指出了何种信息将被传递给函数,函数类型指出了返回值的类型。程序员有时将函数比作一个由出入它们的信息所指定的黑盒子(black boxes)(电工用语)。函数原型将这种观点诠释得淋漓尽致。

函数stonetolb()短小、简单,但包含了全部的函数特性:

2.4.5在多函数程序中使用using编译指令

在程序清单2.5中,两个函数中都包含下面一条using编译指令:

using namespace std;

这是因为每个函数都使用了cout,因此需要能够访问位于名称空间std中的cout定义。

在程序清单2.5中,可以采用另一种方法让两个函数都能够访问名称空间std.即将编译指令放在函数的外面,且位于两个函数的前面:

// ourfunc.cpp -- repositioning the using directive 
#include <iostream>
using namespace std; //affects all function definitions in this file 
void simon(int); // function prototype for simon() 

int main()
{
	simon(3); // call the simon() function 
	cout << "选择一个整数:";
	int count;
	cin >> count; 
	simon(count); // call it again 
	cout << "完成!" << endl;
	cin.get();
	cin.get(); 
	
	return 0; 
}

void simon(int n) // define the simon() function 
{
	cout << "Simon says touch your toes " << n << "times." << endl; 
}

当前通行的理念是,只让需要访问名称空间std的函数访问它是更好的选择。例如,在程序清单2.6中,只有main()函数使用cout,因此没有必要让函数stonetolb()能够访问名称空间std。因此编译指令using被放在函数main()中,使得只有该函数能够访问名称空间std。

总之,让程序能够访问名称空间std的方法有多种,下面是其中的4种。

文件下载(已下载 1200 次)

发布时间:2014/6/4 下午2:44:35  阅读次数:4091

2006 - 2024,推荐分辨率 1024*768 以上,推荐浏览器 Chrome、Edge 等现代浏览器,截止 2021 年 12 月 5 日的访问次数:1872 万 9823 站长邮箱

沪 ICP 备 18037240 号-1

沪公网安备 31011002002865 号