函数（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 ;elsereturn   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移到bcout << 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 ;//指向函数maxdouble 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 ;       // 内层的aa ++ ;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++程序可以由多个程序文件构成。
标识符有特定的存储特性和作用域。一个结构性好的程序，应该遵循最低权限访问的原则，尽量不要使用全局变量。

C++程序设计基础之（第三章）函数相关推荐

PHP-----PHP程序设计基础教程----第三章函数
3.1 初识函数 3.1.1 函数的定义语法: function 函数名([参数1,参数2,......]) {函数体 } (1)function:在声明函数时必须使用的关键字 (2)函数名:创建函 ...
计算机与程序设计基础 vb,《VB程序设计基础》第4章函数与过程
<<VB程序设计基础>第4章函数与过程>由会员分享,可在线阅读,更多相关<<VB程序设计基础>第4章函数与过程(16页珍藏版)>请在人人文库网上搜索 ...
Python程序设计基础（第五章函数练习记录）
继续之前的练习本章首先介绍了如何编写和调用void函数,展示了使用函数对程序进行模块化的好处,并讨论了自顶向下的设计方法.然后,介绍如何将参数传递给函数,讨论了常用的函数库.如生成随机数的函数.接下 ...
《程序设计基础》第五章函数 6-6 字符金字塔 (15 分)
本题要求实现函数输出n行字符金字塔. 函数接口定义: void CharPyramid( int n, char ch); 其中n和ch是用户传入的参数,n为[1, 9]的正整数.要求函数按照如样例所 ...
《程序设计基础》第五章函数 6-10 空心的数字金字塔 (15 分)
本题要求实现一个函数,输出n行空心的数字金字塔. 函数接口定义: void hollowPyramid( int n ); 其中n是用户传入的参数,为[1, 9]的正整数.要求函数按照如样例所示的格式 ...
python语言程序设计2019版第二章课后答案-python语言程序设计基础课后答案第二章...
python语言程序设计基础课后答案第二章以下合法的用户自定义标识符是____________. 导入模块或者模块中的元素要使用关键字________ . 下列哪个函数是用来控制画笔的尺寸的____ ...
java界面编辑教程_java程序设计基础教程第六章图形用户界面编辑.docx
java程序设计基础教程第六章图形用户界面编辑.docx 还剩 27页未读, 继续阅读下载文档到电脑,马上远离加班熬夜! 亲,很抱歉,此页已超出免费预览范围啦! 如果喜欢就下载吧,价低环保! 内容要 ...
给定一个函数做其最佳平方逼近c语言,第三章函数逼近 — 最佳平方逼近.
第三章函数逼近 - 最佳平方逼近内容提要最佳平方逼近最佳平方逼近函数.多项式利用正交多项式计算最佳平方逼近多项式 Chebyshev 级数与最佳一致逼近最佳平方逼近什么是最佳平方逼近设 ...
软考程序员教程-第三章数据库基础知识
软考程序员教程-第三章数据库基础知识第三章数据库基础知识 3.1 基本概念数据库系统(DataBase System,DBS)由数据库(DataBase,DB).硬件.软件和人员4大部分组成 ...
Javascript面向对象编程指南笔记 - 第三章 - 函数
第三章函数第三章函数 3-1 什么是函数 3-1-1 调用函数 3-1-2 参数 3-2 预定义函数 3-2-1 parseInt 3-2-2 parseFloat 3-2-3 isNaN 3- ...

C++程序设计基础之（第三章）函数