C++面向过程程序设计

1. 函数

1.1. 函数的声明与定义

在C++中需要这样声明和定义函数:

   1 #include <iostream>
   2 using namespace std;
   3 
   4 int max(int a, int b); //函数声明
   5 
   6 int main() {
   7     cout << max(4, 3);
   8 }
   9 
  10 /*函数定义*/
  11 int max(int a, int b) {
  12    return a>b? a : b;
  13 }

在C++中,main函数的标准写法有两种。返回int值用于告诉操作系统程序运行的结果,一般返回0表示程序正常结束,返回其它值表示错误代码。

   1 int main() {
   2     //...
   3     return 0;
   4 }
   5 int main(int argc, char *argv[ ]) {
   6     //...
   7     return 0;
   8 }

1.2. 内联函数

参见:C++:内联函数

1.3. 参数默认值

C++允许函数某些参数有默认值(default parameter),比如:

   1 void print(int value, float s = 1.6, char t = '\n', bool c = true);
   2 int main() {
   3     print(14, 48.3, '\t', false);
   4     print(14, 48.3, '\t');
   5     print(14, 48.3);
   6     print(14);
   7 }
   8 void print(int value, float s, char t, bool c) {
   9     cout << value << s << t << c;
  10 }

注意:

1.4. 函数重载

在C语言中,不允许有同名函数。在C++中允许两个以上的函数取相同的函数名,称作函数重载(overload)。例如要写一组功能相同但是参数类型不同的函数:

   1 /*in C*/
   2 void print_double(double d);
   3 void print_int(int i);
   4 void print_string(const char *s);

在C++中这些函数可以使用相同的名字。

   1 // in C++
   2 void print(double d);
   3 void print(int i);
   4 void print(const char *s);
   5 int main() {
   6     print(1.0);
   7     print(2);
   8     print("hello");
   9 }

注意:

   1 void print(int i);
   2 void print(int i, int j=0);
   3 int main() {
   4     print(1, 2); //ok!
   5     print(1); //error! ambiguous!
   6 }

   1 void print(int i, double j);
   2 void print(double i, int j);
   3 int main() {
   4     print(1.0, 2); //ok!
   5     print(1, 2.0); //ok
   6     print(1, 2); //error! ambiguous!
   7 }

2. 引用

引用(reference)就是变量的别名。定义一个变量的引用就相当于给一个变量取了个别名。

   1 int main() {
   2    int i;
   3    int &ref = i;  //ref是i的别名
   4    i = 3;
   5    ref = 5;
   6    float f[5] = {1,2,3,4,5};
   7    float &fref = f[3];
   8 }

注意:

例如:

   1 int main() {
   2     int &ref; // 没有指明引用的对象(即没有初始化)
   3     int &ref2 = 123; //不能引用常量,常量不是左值
   4 }

引用可以作为参数传递

   1 void swap(int &a, int &b) {//型参a和b是实参的别名,即对型参a和b的操作就是对实参的操作。
   2     int t = a;
   3     a = b;
   4     b = t;
   5 }
   6 int main() {
   7     int i = 7, j = -3;
   8     swap(i, j); // i and j swapped
   9 }

引用可以作为返回值

   1 int & index(int a[], int i) {
   2     return a[ i - 1];
   3 }
   4 int main() {
   5     int array[] = {1, 2, 3, 4, 5, 6, 7, 8};
   6     index(array, 1) = 5;
   7 }

在引用前面加const,表示不能通过这个引用(别名)去修改变量(但是原来的变量可能是可变的,也可能是不可变的)

   1 void display (const double &r) {
   2     cout << r << endl;  //可以读取变量的值
   3     r = 12.0; // error!但是不可以修改
   4 }
   5 int main() {
   6     double d = 10.0;
   7     const pi = 3.14159;
   8     display(d);    //可以给const型的引用传普通变量
   9     display(pi);   //可以给const型的引用传const变量
  10     display(10.0);  //可以给const型的引用传常量!!
  11 }

const引用变量可以引用普通变量,普通的引用变量不能引用const变量。比如

   1 int main() {
   2     int i = 5;
   3     const int &r1 = i;
   4     const int j = 10;
   5     const int &r3 = j; // ok
   6     int &r3 = j;       // error
   7 }

3. 模板函数

参见:C++:模板函数


CategoryCpp

C++面向过程程序设计 (2008-05-08 15:45:15由czk编辑)

ch3n2k.com | Copyright (c) 2004-2020 czk.