- 函数（Function）是功能抽象的模块.
- 函数作用 —— 任务划分；代码重用
- 函数是C++程序的重要组件
3.1 函数的定义和调用
- 函数定义由两部分组成：函数首部和函数操作描述
- 函数调用是通过表达式或语句激活并执行函数代码的过程
3.1.1 函数定义
函数定义一般形式
类型 函数名 （ 形式参数表 ）
{
语句序列
}
- 函数头——函数接口，包括：
- 函数返回值类型
函数体中由 return 语句返回的值的类型。没有返回值其类型为void。 - 函数名
用户定义标识符。 - 形式参数表
逗号分隔的参数说明表列，缺省形式参数时不能省略圆括号。
一般形式为：
- 函数返回值类型
类型 参数1 ，类型 参数2 ，… ，类型 参数n
-
函数体——函数的实现代码。
-
return 语句形式：
return 表达式 或 return （表达式 ）作用：
- 返回函数值
- 不再执行后续语句，程序控制返回调用点一个函数体内可以有多个return 语句
- 表达式 返回值的类型与函数类型不相同时，自动强制转换成函数的类型
3.1.2 函数调用
函数调用要做俩件事情：指定函数地址，提供实际参数。函数名是函数的地址，实际参数提供被调用函数执行任务所需要的信息及接收被调用函数返回的信息。
调用形式
函数名 （ 实际参数表 ）
用表达式或语句形式调用;
若函数返回值类型为void，则只能用语句调用
3.1.3 函数原型
- 函数原型的作用是告诉编译器有关函数的信息：
- 函数的名字
- 函数返回的数据类型
- 函数要接受的参数个数、参数类型和参数的顺序
- 编译器根据函数原型检查函数调用的正确性
- 函数原型的形式：
- 类型 函数名 （ 形式参数表 ）;
例 1：使用函数原型的求最大值函数
#include <iostream>
using namespace std ;
double max( double, double ) ; // 函数原型
int main()
{ double a, b, c, m1, m2 ;
cout << "input a, b, c :\n" ;
cin >> a >> b >> c ;
m1 = max( a, b ) ; // 函数调用
m2 = max( m1, c ) ;
cout << "Maximum = " << m2 << endl ;
}
double max( double x, double y ) // 函数定义
{ if ( x > y ) return x ;
else return y ;
}
例 2：函数也可以在使用前定义
#include <iostream>
using namespace std ;
double max( double x, double y ) // 函数定义
{ if ( x > y ) return x ;
else return y ;
}
int main()
{ double a, b, c, m1, m2 ;
cout << "input a, b, c :\n" ;
cin >> a >> b >> c ;
m1 = max( a, b ) ; // 函数调用
m2 = max( m1, c ) ;
cout << "Maximum = " << m2 << endl ;
}
cmath中几个常用的数学函数
3.2 函数参数的传递
C++有三种参数传递机制： 值传递 指针传递 引用传递
3.2.1 传值参数
- 调用函数时，实参表达式的值被复制到相应形参标识的对象中，并按形参类型强制转换
- 函数内对形参的访问、修改，都在形参的标识对象进行
- 函数返回时，形参对象被撤消，不影响实参的值
- 值传送的实参可以是常量、有确定值的变量或表达式
- 函数返回值通过匿名对象传递
1.值传递机制
强制转换类型
{
double a , b, c ;
cin >> a >> b ;
c = add1( a , b ) ;
c = add( 1/a , 1/b) ; //类型强制转换截取整数部分传送给形参
}
double add( int i , int j )
{ return ( i + j ) ; }
值参传递
#include<iostream>
using namespace std ;
int add(int , int ) ;
int main()
{
int a, b, c ;
cin >> a >> b;
c = add(a,b) ;
cout << "c = " << c << endl ;
}
int add(int i, int j )
{ i + + ; j + + ;
return ( i + j );
}
最后结果
2．实际参数求值的副作用
- C++没有规定在函数调用时实际参数的求值顺序
- 若实际参数表达式之间有求值关联，同一个程序在不同编译器可能产生不同的运行结果
至于为什么会产生不同的结果，让我们娓娓道来。对于编译系统来说，他们的计算方式略有不同，分为从左向右求实际参数和自右向左求实际参数。下面给出例子。
#include<iostream>
using namespace std ;
int add( int x , int y )
{ return x + y ; }
int main()
{ int x = 4 , y = 6 ;
int z = add( ++ x , x + y ) ;
cout << " 5 + 11 = " << z << " ?!\n" ;
}
在VC6.0中，求实参是自右向左，也就是先进行x+y=10，再进行++x=5 最后结果就是10+5=15.
在VC2010中，求实参是自左向右，先进行++x=5，再进行x+y=11，最后结果就是11+5=16
要想消除这样的影响我们在写程序时一定要检查或者直接避免。下面我给出避免影响的代码段
++ x ;
int z = add ( x , x + y ) ;
cout << " 5 + 11 = " << z << "\n" ;
3．默认参数
- C++允许指定传值参数的默认值。当函数调用中省略默认参数时，默认值自动传递给被调用函数
- 默认参数在函数原型定义
- 默认参数放在一般参数之后
double power( double real, int n = 2 ) ;
int main()
{ double r = 3.0 ;
cout << power( r ) << endl ;//使用默认参数power ( r，2 )
cout << power( r, 3 ) << endl ;
}
对于默认参数的说明如下：
- C++规定，函数的形式参数说明中设置一个或多个实际参数的默认值，默认参数必须是函数参数表中最右边的（尾部）参数。调用具有多个默认参数的函数时，如果省略的参数不是参数表中最右面的参数，则该参数右边所有参数也应该省略。
- 默认参数应该在函数名第一次出现时指定，通常在函数原型中。若已在函数原型中指定默认参数，则函数定义时不能重复给出。
- 默认值可以是常量、全局变量或函数调用，但不能是局部量。
- 默认参数可以用于内联函数。
3.2.2 指针参数
- 形参指针对应的实际参数是地址表达式，即对象的指针
- 实际参数把对象的地址值赋给形式参数名标识的指针变量
- 被调用函数通过形参指针间接访问实参所指对象
例：交换对象的值
#include<iostream>
using namespace std ;
void swap( int * , int * ) ;
int main()
{ int a = 3 , b = 8 ;
cout << "a = " << a << ", b = " << b << endl ;
swap( &a , &b ) ;
cout <<"after swapping... \n" ;
cout << "a = " << a << ", b = " << b << endl ;
}
void swap( int * x , int * y )
{ int temp = * x ;
* x = * y ;
* y = temp ;
}
结果如下：
为了避免被调用函数对实参所指对象的修改，可以用关键字const约束形参指针的访问特性。
3.2.3 引用参数
- 当形参为引用参数，调用函数时，形参是实参的别名
- 执行函数时，通过别名在实参上操作
- 函数返回，实参的别名取消。
上面的例题交换数据
#include<iostream>
using namespace std ;
void swap( int & , int & ) ;
int main()
{ int a = 3 , b = 8 ;
cout << "a = " << a << ", b = " << b << endl ;
swap( a , b ) ;
cout <<"after swapping... \n" ;
cout << "a = " << a << ", b = " << b << endl ;
}
void swap(int & x , int & y )
{ int temp = x ;
x = y ;
y = temp ;
}
结果为：
再比较一下引用传递和值传递的稍微区别
#include<iostream>
using namespace std ;
void swap( int , int ) ;
int main()
{ int a = 3 , b = 8 ;
cout << "a = " << a << ", b = " << b << endl ;
swap( a , b ) ;
cout <<"after swapping... \n" ;
cout << "a = " << a << ", b = " << b << endl ;
}
void swap( int x , int y )
{ int temp = x ;
x = y ;
y = temp ;
}
结果为：
相信读者也已经完全体会其中的区别了。
例：const引用参数的匿名对象测试
#include<iostream>
using namespace std ;
void anonym(const int & ref )
{ cout << "The address of ref is : " << &ref << endl;
return ;
}
int main()
{ int val = 10 ;
cout << "The address of val is : " << &val << endl;
anonym( val ) ;
anonym( val + 5 ) ;
}
第一次调用anonym函数时，实参是变量名。形参ref与实参val绑定。在程序输出第一行和第二行，实参和形参的地址值相同，说明引用参数与实参对象都是同一个存储单元，引用参数以别名方式在实参上进行操作。无论形参是否被约束，情形都一样。
第二次调用anonym函数时，实参是表达式。C++为const引用建立匿名对象用于存放val+5的值。第三次输出是匿名对象的地址。只用const引用对应的实参可以是常量或者表达式，非约束的引用参数对应的实参必须是对象名。
3.2.4 函数的返回类型
- 函数通过匿名对象返回结果值
- 函数值的类型是匿名对象的类型
- return 语句把表达式的值赋给匿名对象、
Type FunctionName()// Type 可以为各种C++基本数据类型、类类型，以及这些类型的指针或引用
{ // statements
return expression ;
}
1．返回基本类型
有函数原型：
int function(){
......
return x;
}
则执行return语句时，把x的值赋给int类型的匿名对象，返回到函数调用点。
对匿名对象赋值时，如果表达式的值得类型与函数定义的返回值类型不相同，将强制转换成函数的返回类型。
2．返回指针
返回较大值变量的指针
#include<iostream>
using namespace std ;
int * maxPoint(int * x, int * y ) ；
int main()
{ int a, b ;
cout << "Input a, b : " ;
cin >> a >> b ;
cout << * maxPoint( &a, &b ) <<endl ;
}
int * maxPoint(int * x, int * y )
{ if ( *x > *y ) return x ;
return y ;
}
3．返回引用
- C++函数返回对象引用时，不产生返回实际对象时的副本，返回时的匿名对象是实际返回对象的引用
3.3 函数调用机制
- 函数之间的关系
- C++程序从主函数开始执行
- 主函数由操作系统调用
- 函数可以互相调用，自身调用
- 所有函数定义是平行的，不能嵌套定义
- 函数调用用堆栈管理—— 堆栈是先进后出的数据结构
- 函数调用时入栈操作：
- 建立被调用函数的栈空间
- 保护调用函数运行状态和返回地址
- 传递参数
- 控制权交给被调用函数
- 函数返回时出栈操作：
- 返回值保存在临时空间
- 恢复调用函数运行状态
- 释放栈空间
- 根据地址返回调用函数
- 函数调用时入栈操作：
3.3.1 嵌套调用
例：定义一个求 bin ( n, k ) 的函数 。
分析：
定义函数 fact ( m ) = m !
bin ( n , k ) = fact ( n ) / ( fact ( k ) * fact ( n - k ) )
由主函数输入数据 a 、 b ，求 bin ( a , b )
#include<iostream>
using namespace std ;
long fact( int m )
{ int i ; long sum = 1 ;
for ( i = 1 ; i <= m ; sum *= i , i++ ) ;
return sum ;
}
long bin( int n , int k )
{ return (fact(n) / (fact( k ) * fact( n-k ))) ; }
int main()
{ int a , b; long f1 , f2 ;
cout << "Please input data a and b:" << endl ;
cin >> a >> b ;
f1 = fact(a) / (fact( b ) * fact(a-b)) ;
cout << " first: bin(" << a << ', ' << b << ")= " << f1 << endl ;
f2 = bin(a,b) ;
cout << " second: bin(" << a << ', ' << b << ")= " << f2 << endl ;
}
3.3.2 递归调用
递归定义
一个对象部分地由它自己定义，或者是按它自己定义
递归函数
函数直接或间接调用自己
递归函数要求
- 递归形式（算法）
- 递归条件（缩小问题规模）
- 递归终止条件（基本情况）
例：求阶乘
int Factorial(int n)
{ if(n = = 0)//终止条件
return 1 ;
else
return n * Factorial(n - 1 ) ;//递归形式
}
例：递归定义斐波那契数列
int Fibonacci( int n )
{ if ( n <= 2 )
return 1 ;
else
return Fibonacci( n-1 ) + Fibonacci( n-2 ) ;
}
例：反序输出一串字符。可以用到基本的栈的思想来操作。
#include<iostream>
using namespace std ;
void reverse()
{ char ch ; // 局部量
cin >> ch;
if ( ch != '.' )
reverse() ;
cout << ch ;
}
int main()
{ cout << " Input a string : " << endl ;
reverse() ;
cout << endl ;
}
例：反序输出一串数字。
#include<iostream>
using namespace std ;
void reverse(int n)
{ cout<< n % 10 ; // 输出最右一位数字
if(n / 10 != 0)
reverse( n/10 ); // 求商，递归
}
int main()
{ int k ;
cout << "Input a integer number( > 0 ) : "<< endl ;
cin >> k ;
reverse(k ) ;
cout << endl ;
}
例：汉诺塔问题。
#include<iostream>
using namespace std ;
void hanoi( int n, char a, char b, char c )
{ if ( n >= 1 )
{ hanoi( n-1, a, c, b ) ;//以c为过渡，从a移到b
cout << a << " --> " << c << endl ;
hanoi( n-1, b, a, c ) ;
}
}
int main ()
{ int m ;
cout << " Input the number of diskes: " << endl ;
cin >> m ;
hanoi( m, 'A' , 'B' , 'C' ) ;
}
3.4 函数指针
- 函数、应用程序是编译器处理的对象
- 每一个函数模块都有一个首地址，称为函数的入口地址，（函数指针）
- 函数调用：找到函数入口地址；传递参数
- 不带括号的函数名就是函数入口地址
3.4.1 函数的地址
例：函数和数据的测试
#include<iostream>
using namespace std ;
void simple() // 定义一个简单函数
{ cout << "It is a simple program.\n" ; }
int main()
{ cout << "Call function ...\n" ;
simple() ; // 名方式调用
( & simple)() ; // 地址方式调用
( * & simple)() ; // 间址调用
cout << "Address of function :\n" ;
cout << simple << endl ; // 函数名是地址
cout << & simple << endl ; // 取函数地址
cout << *&simple << endl ; // 函数地址所指对象
int a = 100 ; // 声明一个整数对象
cout << "Value of a :\n" ; cout << a << endl;
cout << "Address of a :\n" ; cout << &a << endl;
}
结果为：
也就是说对于一个已经定义的函数，函数名、函数地址（指针）、函数指针所指的对象都是同一个东西，表示函数的入口地址。
C++的函数与数据对象
3.4.2 函数指针
- 指向函数的指针变量简称为函数指针
- 函数的类型是函数的接口
- 可以通过指针变量的间址方式调用函数
1. 函数的类型
以下是类型相同的函数：
double max ( double, double ) ;
double min ( double,double ) ;
double average ( double, double ) ;
定义函数类型： typedef 类型 函数类型 （ 形式参数表 ） ；
它们的类型为：
double ( double, double )
或定义为：
typedef double functionType ( double, double) ;
2．函数指针
若有函数类型为：
double ( double, double ) ;
或：
typedef double functionType ( double, double ) ;
定义指向这类函数的指针变量：
double ( * fp ) ( double, double ) ;
或：
functionType * fp1 , * fp2 ;
例：
double max( double, double ) ;
double min( double, double ) ;
double average( double, double ) ;
typedef double functionType( double, double ) ;
functionType * fp1 , * fp2 ;
fp1 = max ;
fp2 = min ;
fp1 = average ;
fp1 = fp2 ;
3．用函数指针调用函数
例如：
double max( double, double ) ;
double min( double, double ) ;
typedef double functionType( double, double ) ;
functionType * fp ;
fp = max ;//指向函数max
double x = fp( 3.14, 0.516 ) ;
fp = min ;
cout << fp( 0.75, x ) << endl ;
3.5 内联函数和重载函数
- 内联函数是C++为降低小程序调用开销的一种机制
- 函数重载是以同一个名字命名多个函数实现版本
内联函数作用
- 减少频繁调用小子程序的运行的时间开销
内联函数机制
- 编译器在编译时，将内联函数的调用以相应代码代替
内联函数声明
- inline 函数原型
注：
内联函数仅在函数原型作一次声明。
适用于只有1 ~ 5行的小函数，不能含有复杂结构控制语句 ，不能递归调用
内联函数的用法：
inline int smallf( ) ;
int main( )
{ ……
a = smallf();
…...
}
int smallf( )
{
…...
}
或：
inline int smallf ( )
{
…...
}
int main ( )
{ ……
a = smallf ( )
…...
}
如果是这样的话就是错误的。
inline int smallf() ;
int main()
{ ……
a = smallf();
…...
}
inline int smallf() //重复说明，语法错误
{
…...
}
这样又作为普通函数来对待
int smallf() ;
int main()
{ ……
a = smallf();
…...
}
inline int smallf()
{
…...
}
接下来来一个正确的示例：
#include<iostream>
using namespace std ;
inline double volume(double, double) ； // 函数原型
int main()
{
double vol, r, h ;
cin >> r >> h ;
vol = volume(r,h) ;//编译器变换为：vol = 3.14 * r * r * h ;
cout << "Volume = " << vol << endl ;
}
double volume(double radius, double height )
{
return 3.14 * radius * radius * height;
}
3.5.2 函数重载
- 多个同名函数有不同的参数集
- 编译器根据不同参数的类型和个数产生调用匹配
- 函数重载用于处理不同数据类型的类似任务
重载示例：参数个数相同,参数类型不同
#include<iostream>
using namespace std ;
int abs(int a ) ;
double abs(double f) ;
int main()
{ cout << abs(-5 ) << endl ;
cout << abs(-7.8 ) << endl ;
}
int abs(int a)
{ return a < 0 ? -a : a ; }
double abs(double f )
{ return f < 0 ? -f : f ; }
重载示例：参数个数不同
#include<iostream>
using namespace std ;
int max(int a , int b ) ;
int max(int a , int b, int c ) ;
int main()
{ cout << max( 5,3) << endl ;
cout << max(4,8,2) << endl ;
}
int max(int a,int b )
{ return a > b ? a : b ; }
int max(int a , int b, int c )
{ int t ;
t = max( a , b ) ;
return max( t , c ) ;
}
3.6 变量存储特性与标识符作用域
- 标识符存储特性确定内存的生存时间和连接特性
- 标识符作用域是在程序正文中能够被引用的那部分区域
- 标识符的连接特性决定能否被工程中的其他文件引用
3.6.1 存储特性
1．自动存储类
- 自动存储变量存放在栈区
- 进入声明的块时生成，在结束块时删除
- 函数的参数和局部变量都是自动存储类
- 自动存储是变量的默认状态
例：a，b，c，t 都是自动存储类变量
int max(int a , int b, int c )
{ int t ;
t = max(a , b) ;
return max(t , c) ;
}
2．静态存储类
- 关键字extern和static声明静态存储类变量和函数标识符
- extern声明全局量（全局量默认为extern），static声明局部量
- extern和static说明变量时，程序开始执行时分配和初始化存储空间
- extern和static说明函数，表示从程序执行开始就存在这个函数名
例：静态变量与自动变量的测试
#include <iostream>
using namespace std ;
int func();
int main()
{ cout << func() << endl ;
cout << func() << endl ;
}
int func()
{ int a = 0 ; // 自动变量
static int b = 1 ; // 静态变量
a ++ ;
b ++ ;
cout << "auto a = " << a << endl ;
cout << "static b = " << b << endl ;
return a + b ;
}
俩次调用func()得到的值是不一样的，第一回是3，第二回是4
3.6.2 标识符作用域
1．函数原型作用域
函数原型形式参数表中的标识符具有函数原型作用域
例如
以下函数原型编译器认为是相同的：
double funPrototype ( double , double ) ;
double funPrototype ( double a , double b ) ;
double funPrototype ( double x, double y ) ;
2．块作用域
在语句块中声明的标识符具有块作用域
例：不同作用域的同名变量
#include<iostream>
using namespace std ;
int main()
{ int a = 1; // 外层的a
{ int a = 1 ; // 内层的a
a ++ ;
cout << "inside a = " << a << endl ;
} // 内层的a作用域结束
cout << "outside a = " << a << endl ;
} // 外层的a作用域结束
结果是内层的a覆盖了外层的a
3．函数作用域
- 语句标号（后面带冒号的标识符）是惟一具有函数作用域的标识符
- 语句标号用于switch结构中的case标号，goto语句转向入口的语句标号
- 标号可以在函数体中任何地方使用，但不能在函数体外引用
4．文件作用域
- 任何在函数之外声明的标识符具有文件作用域
- 这种标识符从声明处起至文件尾的任何函数都可见
例：使用文件作用域
#include <iostream>
using namespace std ;
int a = 1, b = 1 ;// a, b的作用域从这里开始
void f1( int x )// f1函数可以访问a,b
{ a = x * x ;
b = a * x ;
}
int c ;
void f2( int x, int y )// f2函数可以访问a, b
{ a = x > y ? x : y ;
b = x < y ? x : y ;
c = x + y ;
}
int main()// main 函数可以访问a, b
{ f1( 4 ) ;
cout << "call function f1 :\n" ;
cout << "a = " << a << " , b = " << b << endl ;
f2 (10, 23 ) ;
cout << "call function f2 :\n" ;
cout << "a = " << a << " , b = " << b << " , c = " << c << endl ;
}
5．全局变量和局部变量
- 具有文件作用域的变量称为全局变量；具有函数作用域或块作用域的变量称为局部变量
- 全局变量声明时默认初始值为0
- 当局部量与全局量同名，在块内屏蔽全局量
- 为了在块内访问全局量，可以用域运算符 " :: "
例：在函数体中访问全局变量
#include<iostream>
using namespace std ;
int x ;
int main()
{ int x = 256 ;
cout << "global variable x = " << ::x <<endl ;
cout << "local variable x = " << x << endl ;
}
3.7 多文件程序结构
- 一个C++程序称为一个工程（.dsp）
- 一个工程由一个或多个文件组成
- 一个文件可以包含多个函数定义，但一个函数的定义必须完整地存在于一个文件中
- 一个文件可以被多个应用程序共享
一个好的软件系统应当分解为各种同构逻辑文件
3.7.2 预处理指令
C++编译器工作过程
预处理器 改善程序的组织和管理
预处理指令 所有编译指令以 # 开头，每条指令单独占一行
1．文件包含
include指令在编译之前把指定文件包含到该命令所在位置
形式为：
# include <文件名>
或
# include "文件名 "
2．条件编译
- 形式1
# if 常量表达式
程序段
# endif
- 形式2
# if 常量表达式
程序段1
# else
程序段2
# endif
- 形式3
- # if 常量表达式1
程序段1
# elif 常量表达式2
程序段2
…
# elif 常量表达式n
程序段n
# else
程序段n+1
# endif
3．宏定义指令
用指定正文替换程序中出现的标识符
形式 :
# define 标识符 文本
C语言的宏替换直接做文本替换，没有类型检查。C++也支持。
#include<iostream>
using namespace std ;
//不带参数宏替换。在程序正文中，用3.1415926代替PI
#define PI 3.1415926
//带参数宏替换。在程序正文中，PI*r*r代替area(x)，r是参数
#define area(r) PI*r*r
int main()
{ double x, s;
x=3.6;
s=area(x);
cout<<"s="<<s<<endl;
}
#define 的一个有效应用是在条件编译指令中，避免程序中多次用include指令包含这个头文件，出现重定义的错误 。
3.8 命名空间
- 命名空间是类、函数、对象、类型和其他名字的集合。
- 命名空间令软件组件之间不会产生命名冲突。
- std是C++的标准名空间，包含了标准头文件中各种名字的声明。
3.8.1 标准名空间
C++标准头文件没有扩展名。
iostream iomanip limit fstream string typeinfo stdexcept
使用标准类库的组件时，需要指定名空间。
C++标准名空间 std
使用标准命名空间
//方法一：
#include<iostream>//包含头文件
using namespace std;//指定使用名空间std
int main()
{ int a, b;
cin>>a;//使用std的元素cin
cin>>b;
cout<<"a+b="<<a+b<<'\n'; //使用std的元素cout
}
//方法二：
#include<iostream>
using std::cin;
using std::cout;
int main()
{ int a, b;
cin>>a;
cin>>b;
cout<<"a+b="<<a+b<<'\n';
}
//方法三：
#include<iostream>
int main()
{ int a, b;
std::cin>>a;
std::cin>>b;
std::cout<<"a+b="<<a+b<<'\n';
}
3.8.2 定义名空间
定义命名空间语法：
namespace <标识符>
{ <语句序列> }
namespace A
{ void f();
void g();
}
namespace B
{ void h();
namespace C //嵌套命名空间
{ void i();
}
}
namespace A //为namespace A追加说明
{ void j();
}
3.8.3 使用名空间
使用命名空间语法：
using namespace 名空间 ；
或
using 名空间::元素 ；
3.9 终止程序执行
1．abort函数
函数原型：void abort ( void ) ;
功能：中断程序的执行，返回C++系统。在stdlib声明。
用法：
#include <iostream>
using namespace std;
#include <cstdlib>
int main(){
int a,b;
cin>>a>>b;
if(b==0)
{
cout<<"除数为零！"<<endl;
absort();
}
else cout<<a/b<<endl;
}
2．assert函数
函数原型：void assert ( int expression ) ;
功能：若expression的值为false，中断程序的执行，显示中断执行所在文件和程序行，返回C++系统。在assert声明。
用法：
#include<iostream>
using namespace std;
#include <cassert>
void analyzeScore(int s)
{
assert(s>=0);//s<0时终止
assert(s<=100);//s>100时终止
}
int main(){
const int max=100;
const int min=0;
int score;
cin>>score;
analyzeScore(score);
cout<<"The score is effective!\n";
}
3．exit函数
函数原型：void exit ( int status ) ;
功能：中断程序的执行，返回退出代码，回到C++系统。在stdlib声明。其中退出代码status是整型常量，返回操作系统，C++看不到exit的返回值。
用法：
exit();
exit(1);
exit(0)
小结
- 函数的作用是程序的功能划分和代码重用。
- 函数的参数是函数与外部通信的接口。形式参数与实际参数有三种传递方式：传值参数、指针参数和引用参数。
- return语句可以通过匿名对象使函数返回一个表达式的值。
- 内联函数是为减少调用开销的小程序。重载函数是名字相同，实现版本不同的函数。
- 函数可以用语句或表达式调用。已经定义的函数可以互相调用，可以递归调用。main函数是程序的启动函数。
- 调用一个函数需要的信息包括：函数地址和对应的实际参数。
- C++程序可以由多个程序文件构成。
- 标识符有特定的存储特性和作用域。一个结构性好的程序，应该遵循最低权限访问的原则，尽量不要使用全局变量。
2473
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
