devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++入门——Day6_C++函数编程模块_针对每种类型,要求给出函数(模块)的原型说明、函数功能说明和为何是这种类型的原

作者：weixin_40725706 | 2024-07-02 21:21:29

赞

踩

针对每种类型,要求给出函数(模块)的原型说明、函数功能说明和为何是这种类型的原

一、复习函数的基本知识

 

库函数

自定义函数

先写段程序，复习下自定义函数

  1. #include <iostream>
  2.  
  3. void simple(void);
  4. using namespace std;
  5.  
  6. int main(void)
  7. {
  8.  
  9.     cout << "main() will call the somple() function " << endl;
  10.     simple();
  11.  
  12.     return 0; 
  13. }
  14. void simple(void)
  15. {
  16.     cout << "I'm simple but a function." << endl;
  17. }

自定义函数的三个部分：

函数定义，函数声明，函数调用，缺一不可

1：定义函数

函数分为有返回值和没有返回值的

没有返回值就是void函数，通用格式如下：

void functionName (parameterList)

{

        statement(s)

        return;   //可写可不写，没返回值一般不写

}

其中的paramenterList是指传递给函数的参数类型和数量，例如：
void cheers (int n)

{

         for(int i = 0; i <n ; i++)

                cout << "Cheers!";

        cout << endl;

}

这里的int意思就是，在调用cheers函数的时候，应该给它一个Int值作为参数传递给它

有返回值的函数将生成一个值，并将它返回给调用函数，通用格式如下：

typeName functionName(paramterList)

{

         statements;

        return value;

}

对于有返回值的函数，必须使用返回语句，以便把值返回给调用函数。

值本身可以是常量、变量、表达式，只是其结果的类型必须为typeName类型或者可以被转换为typeName（比如说我们返回类型是double，但是返回一个int表达式，int会被强转为double类型）

C++对于返回值的类有限制：不能是数组，但是可以是其他任何类型，比如结构对象等（但是可以把数组作为结构或对象组成部分来返回）

函数在执行返回语句后结束。如果函数包含多条返回语句，则函数在执行遇到第一条返回语句后结束。

int bigger (int a , int b)

{

        if(a>b)

                return a;

        else

                return b;

}

2:函数原型和函数调用

看如下程序，体会自定义有返回值和没有返回值的函数

  1. #include <iostream>
  2.  
  3. using namespace std;
  4. void cheers(int n);//声明
  5. double cube(double x);
  6.  
  7. int main(void)
  8. {
  9.     cheers(5);//调用
  10.     
  11.     cout << "Give me a number: " << endl;
  12.     double side;
  13.     cin >> side;
  14.     
  15.     double volume = cube(side);
  16.     cout << side << " side cube = " << volume << endl;
  17.  
  18.     cheers(cube(2));  //自定义函数调用自定义函数，并进行double转int的操作
  19.  
  20.     return 0; 
  21. }
  22. void cheers(int n)      //无返回值
  23. {
  24.     for (int i = 0; i < n; i++)
  25.     {
  26.         cout << "Cheers!" << endl;
  27.     }
  28. }
  29. double cube(double x)     //有返回值
  30. {
  31.     x = x * x * x;
  32.     return x;
  33. }

结果：

Cheers!
Cheers!
Cheers!
Cheers!
Cheers!
Give me a number:
3
3 side cube = 27
Cheers!
Cheers!
Cheers!
Cheers!
Cheers!
Cheers!
Cheers!
Cheers!

*

1）自定义无返回值cheers,自定义有返回值cube

2）把输入作为cube的参数，返回double类型

3）自定义函数cheers引用自定义函数cube

1）为什么需要原型？
就是头文件下面为什么要再声明一下

函数原型描述了函数到编译器的结构，也就是它将函数的返回值类型及参数类型数量告诉编译器

cube()函数完成计算后，把返回值放到了指定位置——可能是寄存器，可能是内存，然后调用函数（main()）从这个为之取得返回值

C++编译器并不会在文件中进一步查找，这样效率太低了，所以最好能提供原型

2）原型的语法

函数原型并不需要提供变量名，有类型列表有足够了。比如对于cheer()原型，我们只提供了参数类型：

void  cheers(int);

比方说我们去饭店吃饭，只需要打电话告诉饭店，我们有几个人，我们吃什么菜，我们有几个人，而不需要把每个人的名字告诉饭店一个道理

所以说比方说下面的原型：

double cube(double x)写成double cube (double) 一样是可以编译的！

3）原型的功能

要确保以下几点：

·编译器正确处理函数返回值；

·编译器检查使用的参数数目是否正确

·编译器检查使用的参数类型是否正确

但是如果是较大的数据类型转换为较小类型时，有些编译器会发出警告，指出数据可能丢失

比如把2.33E27转为int类型，这种值就不会被正确转换

二、函数参数和按值传递

C++通常按值传递参数，这意味着将数值参数传递给函数，而后者将其赋给新的变量

比如：double volume = cube  (side);

→   side是一个变量，前面定义为5

cube的函数头如下：double cube (double x)

→   函数被调用时，该函数创建一个新的名为x的double变量，把它初始化为5

→    这样cube()执行的操作将不会影响main()中的数据。

→    cube使用的是side的副本，而不是原来的数据

用于接收传递值得变量被称为形参，比如这里double 的x

传递给函数的值被称为实参，比如原来的side

1：多个参数

1）函数内定义两个变量，哪怕是相同类型，也要写全

void fifi (float a, float b)

2)与一个参数一样，原型中的变量名不必与定义中的变量名相同，甚至可以省略，但是最好写上，至少知道人家是干嘛用的

见如下程序：演示修改形参并不会影响调用函数中的数据

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. void n_chars(char c, int n);
  6.  
  7. int main(void)
  8. {
  9.     char ch;
  10.     int times;
  11.  
  12.     cout << "Please enter a character: ";
  13.     cin >> ch; //cin.get()也行
  14.  
  15.     while(ch != 'q')
  16.     {
  17.         cout << "Enter a integer: ";
  18.         cin >> times;
  19.  
  20.         n_chars(ch,times);
  21.         cout << endl;
  22.         cout << "Enter another character or press q_key to quie: " << endl;
  23.         cin >> ch;
  24.     }
  25.     return 0; 
  26. }
  27.  
  28. void n_chars(char c, int n)
  29. {
  30.     while (n-- >0)
  31.     {
  32.         cout << c;
  33.     }
  34. }

结果：

Please enter a character:

1
Enter a integer: 10
1111111111
Enter another character or press q_key to quie:
q

 

*

1）声明了ch和times分别作为n_chars的两个参数，然后通过函数返回内容

2：另外一个接收两个参数的函数

题目如下：

美国许多州都采用某种纸牌游戏来发行彩票，让参与者从卡片中选择一定数目的选项。

例如：从51个数字中选取6个，随后管理者随机抽取6个数。如果参与者选择的数字与这6个完全相同，赢得几百万美金。函数计算中奖概率

首先，必须从51个数中选取6个数，而中奖的概率为1/R，R的计算公式为：

R=\frac{51\times 50\times 49\times 48\times 47\times 46}{6\times 5\times 4\times 3\times 2\times 1}

选择6个数时，分母为6！，分子是连续6个整数的乘积，从51开始连续递减，可以采用for循环计算

long double result = 1.0;

for(n = numbers , p = picks ; p > 0 ; n-- , p--)（numbers是一共从多少个数中选择）

        result = result * n / p;(pick是选取数的个数)

程序：

  1. #include <iostream>
  2.  
  3. using namespace std;
  4. long double probability(unsigned int numbers,unsigned int picks);
  5.  
  6. int main(void)
  7. {
  8.     unsigned int total,choices;
  9.     cout << "Enter the total number of choices on the game card and the number of picks allowed: " << endl;
  10.     while((cin >> total >> choices) && choices <= total)
  11.     {
  12.         cout << "You have one chance in " << probability(total,choices) << " of winning";
  13.         cout << "Please enter next two number(q to quit)";
  14.     }
  15.     cout << "Bye";
  16.     
  17.     return 0; 
  18. }
  19. long double probability(unsigned int numbers,unsigned int picks)
  20. {
  21.     double n,p;
  22.     long double result = 1.0;
  23.  
  24.     for(n = numbers, p = picks; p > 0; n--,p--)
  25.         result = result * (n / p);
  26.  
  27.     return result;
  28. }

结果（输出是R,概率是1/R）:

Enter the total number of choices on the game card and the number of picks allowed:
49
6
You have one chance in 1.39838e+07 of winningPlease enter next two number(q to quit)100
10
You have one chance in 1.73103e+13 of winningPlease enter next two number(q to quit)

*

1）这个程序就演示了可以在函数中使用两种局部变量。

首先是形参（numbers和picks）；其次是其他局部变量（result、n、p）

形参和局部变量的主要区别是，形参从调用函数那里获得自己的值，而其他变量是从函数中获得自己的值

2）注意可以这样写：

while((cin >> total >> choices) && choices <= total)，代表如果输入成功

三、函数和数组

如何把函数和数组结合起来？

假设使用一个数组来记录家庭野餐中每人吃了多少甜品，现在要统计总数，来使用函数实现

我们返回值部分不能为数组，但是参数部分可以是

比如以下声明：

int   sum_arr (  int arr[] , int n )

这里的arr看起来是一个数组，其实它是一个指针，但是函数编写时，可以把它看成是数组

下面程序将演示如同使用数组名那样使用指针

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. const int ArSize = 8;
  6.  
  7. int sum_arr(int arr[],int n);
  8.  
  9. int main(void)
  10. {
  11.     int cookies[ArSize] = {1,2,4,8,16,32,64,128};//数组定义好了
  12.  
  13.     int sum = sum_arr(cookies,ArSize); //函数返回总数
  14.     cout << "Total cookies eaten: " << sum << endl;
  15.     
  16.     return 0; 
  17. }
  18. int sum_arr(int arr[],int n)//它用了两个参数，一个是数组，一个是数组数量
  19. {
  20.     int total = 0;
  21.     for(int i = 0; i < n; i++)//很明显，我们用数组的数量和求和
  22.     {
  23.         total += arr[i];
  24.     }
  25.     return total;
  26. }

结果：Total cookies eaten: 255

1：函数如何使用指针处理数组

大多数情况下，C++和C一样，也将数组名视为指针，它将数组名解释为第一个元素的地址：

cookies  ==  & cookies [0]

但是也有一些例外，比如

1）数组声明使用数组名来标记存储位置

2）对数组名使用sizeof将得到整个数组的长度（字节为单位）

3）&用于数组名时，返回整个数组的地址

再来看这个函数调用：int sum = sun_arr(cookies , ArSize)

cookies是数组名，而C++规定它是第一个元素的地址，因此函数传递的是地址。所以cookies类型必须是int指针，即int *。所以正确的函数头应该是：
in sun_arr ( int * arr , int n)

在函数头或函数原型中，int * arr和int arr[]含义相同,它们都意味着arr是一个int指针

arr[i] == *(ar + i)

&arr [i]  ==  ar +  i

将指针（数组名+1）意味着加上了一个与指针指向的类型的长度相等的值，就是指针偏移

2：将数组作为参数意味着什么？

sum_arr把cookies的第一个元素的地址和数组中的元素传递给了sum_arr函数。

sum_arr函数将cookies的地址赋给指针变量arr，将ArSize赋给int变量n

函数在传递数组的时候，使用的是原来的数组

看下面的函数，这回我们使用指针来演示上面的程序

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. const int ArSize = 8;
  6.  
  7. int sum_arr(int arr[],int n);
  8.  
  9. int main(void)
  10. {
  11.     int cookies[ArSize] = {1,2,4,8,16,32,64,128};//数组定义好了
  12.     cout << "array adress: " << &cookies << endl;
  13.     cout << "size of cookies: " << sizeof(cookies) << endl; //32
  14.  
  15.     int sum = sum_arr(cookies,ArSize); //函数返回总数
  16.     cout << "Total cookies eaten: " << sum << endl;
  17.  
  18.     sum = sum_arr(cookies,3);
  19.     cout << "3 cookies eaten: " << sum << endl;
  20.     
  21.     return 0; 
  22. }
  23. int sum_arr(int arr[],int n)//它用了两个参数，一个是数组，一个是数组数量
  24. {
  25.     int total = 0;
  26.     cout << "arr adress: " << arr << endl;
  27.     cout << "size of arr: " << sizeof arr << endl;//这里返回的不是数组，而是指针，8个字节，int *占用8字节
  28.  
  29.     for(int i = 0; i < n; i++)//很明显，我们用数组的数量和求和
  30.     {
  31.         total += arr[i];
  32.     }
  33.     return total;
  34. }

结果：

array adress: 0x3cebbff7d0
size of cookies: 32
arr adress: 0x3cebbff7d0
size of arr: 8
Total cookies eaten: 255
arr adress: 0x3cebbff7d0
size of arr: 8
3 cookies eaten: 7

*

1）

cout << "size of cookies: " << sizeof(cookies) << endl; 这里打印的是数组的大小

2）cout << "arr adress: " << arr << endl;

我们sum_array的地址和cookies地址完全一样，所以我们知道sum_array其实就是使用了cookies的地址来进行运算

3）cout << "size of arr: " << sizeof arr << endl;//这里返回的不是数组，而是指针，8个字节，int *占用8字节

3：更多数组函数示例

先看一个案例：考虑对房地产数组执行的操作。两个基本操作是，将值读入到数组中和显示数组的内容。

另外添加另一个操作：重新评估每种房地产的值。（所有房地产都以相同的比率增加或减少）

  1. #include <iostream>
  2.  
  3. using namespace std;
  4. const int Max = 5;
  5.  
  6. int fill_array(double arr[],int limit);
  7. void show_array(const double arr[],int n);
  8. void revalue(double r,double arr[], int n);
  9.  
  10. int main(void)
  11. {
  12.     
  13.     double properties[Max];//5个double类型数组
  14.    
  15.     int size = fill_array(properties,Max);//添加数组的方法
  16.     
  17.     show_array(properties,size);
  18.  
  19.     if(size > 0)
  20.     {
  21.         cout << "Enter revaluation factor: ";
  22.         double factor;
  23.  
  24.         while(!(cin >> factor))
  25.         {
  26.             cin.clear();
  27.             while ((cin.get() != '\n'))
  28.             {
  29.                 continue;
  30.             }
  31.             cout << "Bad input : input process terminated." << endl;      
  32.         }
  33.         revalue(factor,properties,size);
  34.  
  35.         show_array(properties,size);
  36.     }
  37.     cout << "Done!\n";
  38.     cin.get();
  39.     cin.get();
  40.     return 0; 
  41. }
  42. int fill_array(double arr[],int limit)//
  43. {
  44.     double temp;
  45.     int i;
  46.     for (i = 0; i < Max; i++)
  47.     {
  48.         cout << "Enter value #" << i + 1 << ":";
  49.         cin >> temp;
  50.         if(!cin)
  51.         {
  52.             cin.clear();
  53.             while (cin.get() != '\n')
  54.             {
  55.                 continue;
  56.             }
  57.             cout << "Bad input : input process terminated." << endl;
  58.             break;
  59.         }
  60.         else if(temp < 0)
  61.             break;
  62.         else
  63.             arr[i] = temp;
  64.     }
  65.     return i;
  66. }
  67. void show_array(const double arr[],int n)//加上const以后，就不能通过指针来修改对象了
  68. {
  69.     for (int i = 0; i < n; i++)
  70.     {
  71.         cout << "Property #" << i+1 << " : $";
  72.         cout << arr[i] << endl;
  73.     } 
  74. }
  75. void revalue(double r,double arr[], int n)//r是比例系数
  76. {
  77.     for(int i = 0; i < n ; i++)
  78.     {
  79.         arr[i] *= r;
  80.     }
  81. }

结果：

输入：
Enter value #1:1000
Enter value #2:2000
Enter value #3:3000
Enter value #4:4000
Enter value #5:5000

显示：

Property #1 : $1000
Property #2 : $2000
Property #3 : $3000
Property #4 : $4000
Property #5 : $5000

修改因子：
Enter revaluation factor: 2
Property #1 : $2000
Property #2 : $4000
Property #3 : $6000
Property #4 : $8000
Property #5 : $10000
Done!

*程序说明：

1）填充数组

该函数指定两个参数，一个是数组名，另一个是指定读取的最大元素数，该函数返回实际读取的元素数，还要注意判断它输入是否正确和输入是否大于0这两个条件，然后使用for循环，创建临时值，挨个放进去

2）显示数组

这个就是循环+显示数组元素

3）修改数组

它需要给函数传递三个参数，分别是因子，数组和元素数目，没有返回值

4：使用数组区间和函数

除了上面例子中提供数组中的数据类型、数组的起始位置和数组中元素数量，还有另一种方法：

即指定元素区间（range），这可以通过传递两个指针来完成：一个指针标识数组开头，另一个指针标识数组的尾部，看下例（还是饼干）：

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. const int ArSize = 8;
  6.  
  7. int sum_arr(const int * begin, const int * end);
  8.  
  9. int main(void)
  10. {
  11.     int cookies[ArSize] = {1,2,4,8,16,32,64,128};
  12.  
  13.     int sum = sum_arr(cookies, cookies + ArSize); 
  14.     cout << "Total cookies eaten: " << sum << endl;
  15.     
  16.     return 0; 
  17. }
  18. int sum_arr(const int * begin, const int * end)
  19. {
  20.     int total = 0;
  21.     const int * pt;
  22.  
  23.     for(pt = begin; pt != end; pt++)
  24.         total += *pt; 
  25.     return total;
  26. }

结果：Total cookies eaten: 255

*

1）定义了指针的开头和指针的结尾，求和就用指针内容

2）调用函数的开头结尾位置采用cookies和cookies + ArSize

5：指针和const

三个const的用法

①const int *pt

②int *const pt;

③const int *const pt;

①const int *pt等效于  int const *pt

使用const，就不能通过指针修改数组了，比如如下程序：

  1. int main(void)
  2. {
  3.     int n =10;
  4.     int *pt = &n;
  5.  
  6.     cout << "1)n= " << n << endl;
  7.     
  8.     *pt = 20;//通过指针修改了n的对象
  9.     cout << "2)n= " << n << endl;
  10.     
  11.     return 0; 
  12. }

1)n= 10
2)n= 20

但是如果加上const，就不能通过指针来修改了

  1. int main(void)
  2. {
  3.     int n =10;
  4.     const int *pt = &n;
  5.  
  6.     cout << "1)n= " << n << endl;
  7.     
  8.     *pt = 20;//通过指针修改了n的对象
  9.     cout << "2)n= " << n << endl;
  10.     
  11.     return 0; 
  12. }

结果如下：

 报错说*pt是只读，所以不能通过const修改后的指针来修改原值

但是指针还是可以指向其他地方的，如下：

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5.  
  6. int main(void)
  7. {
  8.     int n =10;
  9.     int m = 100;
  10.     const int *pt = &n;
  11.  
  12.     cout << "1)n= " << n << endl;
  13.     
  14.     //*pt = 20;//通过指针修改了n的对象
  15.     pt = &m;
  16.     cout << "*pt = " << *pt << endl;
  17.     cout << "m = " << m << endl;
  18.     
  19.     return 0; 
  20. }

还是可以指向其他位置，比如m

1)n= 10
*pt = 100
m = 100

②int * const pt;   

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. int main(void)
  6. {
  7.     int n =10;
  8.     int *const pt = &n;
  9.  
  10.     cout << "1)n= " << n << endl;
  11.     *pt = 20;
  12.     cout << "2)n = " << n << endl;
  13.     
  14.     return 0; 
  15. }

这时候把*放到了const的前面，就可以通过pt指针修改原n值

结果：
1)n= 10
2)n = 20

再把pt指针指向m

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. int main(void)
  6. {
  7.     int n =10;
  8.     int *const pt = &n;
  9.  
  10.     cout << "1)n= " << n << endl;
  11.     *pt = 20;
  12.     cout << "2)n = " << n << endl;
  13.  
  14.     pt = &m;
  15.     
  16.     return 0; 
  17. }

这时候就报错了，说明*const pt可以修改指向数值的值，但是只能指向一个值，不能指向任意变量

③const int *const pt;

这就说明了，你既不能通过指针修改内容，也不能指向其他位置

尽可能使用const

将指针参数声明为指向常量数据的指针有两条理由：

·这样可以避免由于无意间修改数据而导致的编程错误

·使用const使得函数能够处理const和非const实参，否则将只能接收非const数据

如果条件允许，则应将指针形参声明为指向const的指针

如果函数形参是const,那么不管函数是const或者非const，都能进行调用

如果函数形参是非const，那么如果函数是const，就不能进行调用

所以在使用的时候，最好给形参设置成const指针！

四、函数和二维数组

1:

跟一维数组类似，假设

int date[3] [4] = {{1,2,3,4},{5,6,7,8},{2,4,6,8}};

int total =sum(data , 3)，sum函数就是数组名+数组中的元素

data是一个数组名，有三个元素，第一个元素本身是数组，有4个int组成，因此data类型是指向由4个int组成的数组的指针，正确的原型如下：

int sum(int(*ar2)[4], int size))（指针的数组）

这声明了将4个指向int的指针组成的数组

而不是由一个指向由4个int组成的数组的指针

如：int ar2[4]，（这是数组的指针）

二维数组函数写成下面这样子，可读性更强；

int sum(int ar2[] [4] , int size);

2:二维数组遍历

因此二维数组的遍历就需要循环嵌套，外层访问行，内层访问列

  1. int sum(int are[][4],int size)
  2. {
  3.     int total = ;
  4.     for(int r = 0; r < size; r++)
  5.     {
  6.         for(int c = 0;c <4; c++)
  7.         {
  8.             total += ar2[r][c];
  9.         }
  10.     }
  11.     return total;
  12. }

3：提取元素

可以用数组表示法的原因是：ar2指向数组的第一个元素，因此ar+r指向编号为r的元素，又因为元素本身又是数组，随意ar2[r]是由4个int组成的数组的名称，所以ar2[r][c]是4个int组成的数组中的一个元素（最简单的方法），必须对指针执行两次才能解除引用，如下：
 

ar2[r][c]  ==  *(*(ar2+r)+c)

先对行指针+r,利用*取出行元素，就是数组，然后对数组名+c，就是针对这个数组偏移，然后再*取出元素



五、函数和C风格字符串

1：表示字符串的三种方法

·char数组     char ghost[15] = "galloping";

·用引号括起来的字符串常量（字符串字面值）   

·被设置为字符串的地址的char指针       char * str = "galumping"

看如下例子：使用一个函数来计算特定的字符再字符串中出现的次数

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. unsigned int c_in_str(const char *str, char ch);
  6.  
  7. int main(void)
  8. {
  9.     char mmm[15] = "minimum";//第一种字符数组的方式
  10.     const char * wail = "ululate"; //第二种字符指针方式 //char * wail = (char *"ululate")也行
  11.  
  12.     unsigned int ms = c_in_str(mmm,'m');
  13.     unsigned int us = c_in_str(wail,'u');
  14.  
  15.     cout << ms << " m characters in " << mmm << endl;
  16.     cout << us << " u characters in " << wail << endl;
  17.  
  18.     return 0;
  19. }
  20. unsigned int c_in_str(const char *str, char ch)
  21. {
  22.     unsigned int count = 0;
  23.  
  24.     while ((*str))
  25.     {
  26.         if(*str == ch)
  27.             count++;    
  28.     str++;
  29.     }   
  30.     return count;
  31. }

3 m characters in minimum
2 u characters in ululate

2：返回C风格字符串的函数

函数无法返回字符串，但可以返回字符串的地址，这样效率更高

下面定义一个buildstr()函数，返回一个指针，接收两个参数，一个字符一个数字。函数使用new创建一个长度和数字参数相等的字符串，然后将每个元素都初始化为该数组

  1. #include <iostream>
  2.  
  3. using namespace std;
  4. char * buildstr(char c, int n);
  5.  
  6. int main(void)
  7. {
  8.     char ch;
  9.     cout << "Enter a character: ";
  10.     cin >> ch;
  11.  
  12.     int times;
  13.     cout << "Enter a integer: ";
  14.     cin >> times;
  15.  
  16.     char *ps = buildstr(ch,times);
  17.     cout << ps << endl;
  18.     delete[] ps;
  19.     ps = buildstr('+',20);
  20.     cout << ps << "-Done-" << ps << endl;
  21.     delete[]ps;
  22.  
  23.     return 0;
  24. }
  25. char * buildstr(char c, int n)
  26. {
  27.     char * pstr = new char[n+1];//new创建数组
  28.     pstr[n] = '\0';//最后一个留给空字符
  29.     for(int i = 0 ; i < n; i++)
  30.     {
  31.         pstr[i] = c;
  32.     }
  33.     return pstr;
  34. }

结果：

Enter a character: V
Enter a integer: 20
VVVVVVVVVVVVVVVVVVVV
++++++++++++++++++++-Done-++++++++++++++++++++

*

1）要注意new字符串的时候多留一位给我们的空格

2）new完了要记得delete

六、函数和结构

结构变量的行为更接近基本的单值变量，在这种情况下，函数将使用原始结构的副本，另外，函数也可以返回结构

与数组名就是数组的第一个元素的地址不同，结构名只是结构的名称，要获得结构的地址，必须使用地址运算符&

如果结构非常大，则赋值结构将增加内存要求，所以许多C程序员进行函数传递和返回，更喜欢指针来访问结构体的内容

C++提供了第三种选择——按引用类型

1：传递和返回结构

看如下程序：

  1. #include <iostream>
  2.  
  3. using namespace std;
  4. const int Mins_per_hr = 60;
  5.  
  6. struct travel_time
  7. {
  8.     int hours;
  9.     int mins;
  10. };
  11.  
  12. travel_time sum(travel_time t1, travel_time t2);
  13. void show_time(travel_time t);
  14.  
  15. int main(void)
  16. {
  17.     travel_time day1 = {5,45};
  18.     travel_time day2 = {4,55};
  19.  
  20.     travel_time trip = sum(day1,day2);
  21.  
  22.     cout << "Two days :" << trip.hours << " hours , " << trip.mins << " mins." << endl;//这样写还是有些复杂，再定义一个shouwtime函数
  23.  
  24.     travel_time day3 = {4,32};
  25.     cout << "Three days :" ;
  26.     show_time(trip);
  27.  
  28.     return 0;
  29. }
  30. travel_time sum(travel_time t1, travel_time t2)
  31. {
  32.     travel_time total;
  33.  
  34.     total.mins = (t1.mins + t2.mins) % Mins_per_hr;
  35.     total.hours = t1.hours + t2.hours + (t1.mins + t2.mins) / Mins_per_hr;   //  (t1.mins + t2.mins) / Mins_per_hr会自动取整的
  36.  
  37.     return total;
  38. }
  39. void show_time(travel_time t)
  40. {
  41.     cout << t.hours << " Hours, " << t.mins << "Minutes." << endl;//没返回值
  42. }

结果：

Two days :10 hours , 40 mins.
Three days :15 Hours, 12Minutes.

*这里所有的参数类型都是结构体

2：另一个处理结构的函数示例

定义两个结构，用于表示两种不同的描述位置的方法，然后开发一个函数，将一种格式转换为另一种格式，并显示结果

  1. #include <iostream>
  2. #include <cmath>
  3.  
  4. using namespace std;
  5.  
  6. struct polar
  7. {
  8.     double distance;
  9.     double angle;
  10. };
  11.  
  12. struct rect
  13. {
  14.     double x;
  15.     double y;
  16. };
  17.  
  18. polar rect_to_polar(rect xypos);
  19. void show_polar(polar dapos);
  20.  
  21. int main(void)
  22. {
  23.     rect rplace;
  24.     polar pplace;
  25.  
  26.     cout << "Enter the x and y value: ";
  27.     while (cin >> rplace.x >> rplace.y)
  28.     {
  29.         pplace = rect_to_polar(rplace);//将直角坐标系转为极坐标系，输入的一定是直角坐标系新建的
  30.         show_polar(pplace);//要显示极坐标系，参数肯定是极坐标系
  31.         cout << "Next two numbers(q to quit):";
  32.     }
  33.     return 0;
  34. }
  35. polar rect_to_polar(rect xypos)
  36. {
  37.     polar answer;
  38.     answer.distance = sqrt(xypos.x * xypos.x + xypos.y * xypos.y);
  39.     answer.angle = atan2(xypos.y,xypos.x);//atan2返回弧度，还需要转化为角度
  40.     return answer;
  41. }
  42.  
  43. void show_polar(polar dapos)
  44. {
  45.     const double Rad_to_deg = 57.29577951;
  46.     cout << "Distance = " << dapos.distance << endl;
  47.     cout << "Angel = " << dapos.angle * Rad_to_deg << "degree" << endl;
  48. }

结果：

Enter the x and y value: 30
40
Distance = 50
Angel = 53.1301degree
Next two numbers(q to quit):-100
100
Distance = 141.421
Angel = 135degree
Next two numbers(q to quit):q

*

1）函数引用结构体类型，结构体类型应该放在最前面，不然报错

2）while (cin >> rplace.x >> rplace.y)，如果输入成功

3：传递结构的地址

可以对上述的程序进行修改

  1. #include <iostream>
  2. #include <cmath>
  3.  
  4. using namespace std;
  5.  
  6. struct polar
  7. {
  8.     double distance;
  9.     double angle;
  10. };
  11.  
  12. struct rect
  13. {
  14.     double x;
  15.     double y;
  16. };
  17.  
  18. void rect_to_polar(const rect *pxy , polar * pda);
  19. void show_polar(const polar *pda);
  20.  
  21. int main(void)
  22. {
  23.     rect rplace;
  24.     polar pplace;
  25.  
  26.     cout << "Enter the x and y value: ";
  27.     while (cin >> rplace.x >> rplace.y)
  28.     {
  29.         //pplace = rect_to_polar(rplace);
  30.         rect_to_polar(&rplace,&pplace);//两个值，第一个是直角坐标系的指针，第二个是极坐标系的指针
  31.         //show_polar(pplace);
  32.  
  33.         show_polar(&pplace);//直接用地址就行了，没有返回值
  34.         cout << "Next two numbers(q to quit):";
  35.     }
  36.     return 0;
  37. }
  38. void rect_to_polar(const rect *pxy , polar *pda)//定义两个地址，只需要把地址换了就行
  39. {
  40.     pda->distance = sqrt(pxy->x*pxy->x + pxy->y*pxy->y);
  41.     pda->angle = atan2(pxy->y, pxy->x);//atan2返回弧度，还需要转化为角度
  42. }
  43.  
  44. void show_polar(const polar *pda)
  45. {
  46.     const double Rad_to_deg = 57.29577951;
  47.     cout << "Distance = " << pda->distance << endl;
  48.     cout << "Angel = " << pda->angle * Rad_to_deg << "degree" << endl;
  49. }

结果：

Enter the x and y value: 30
40
Distance = 50
Angel = 53.1301degree
Next two numbers(q to quit):-100
100
Distance = 141.421
Angel = 135degree
Next two numbers(q to quit):q

*

1）函数内部传递的是指针，参数是指针，没有返回值

七、函数和string对象

string对象和结构更为相似，例如，可以将一个结构赋给另一个结构，也可以将一个对象赋给另一个对象。可以将结构作为完整实体传递给函数

下面的程序声明了一个string对象数组，并将该数组传递给一个函数显示内容：

  1. #include <iostream>
  2.  
  3. using namespace std;
  4. const int SIZE = 5;
  5. void display(const string sa[], int n);
  6.  
  7. int main(void)
  8. {
  9.     string list[SIZE];
  10.     cout << "Enter " << SIZE << " favorite food: " << endl;
  11.     for (int i = 0; i < SIZE; i++)
  12.     {
  13.         cout << i+1 << ": ";
  14.         getline(cin,list[i]);
  15.     }
  16.     cout << "Your list" << endl;
  17.     display(list,SIZE);
  18.  
  19.     return 0;
  20. }
  21. void display(const string sa[], int n)
  22. {
  23.     for (int i = 0; i < n; i++)
  24.     {
  25.         cout << i+1 << ": " << sa[i] << endl;
  26.     }
  27. }

结果：

Enter 5 favorite food:
1: break
2: milk
3: icecr
4: saled
5: cake
Your list
1: break
2: milk
3: icecr
4: saled
5: cake

八、函数与array对象

假设 要使用一个array对象存储一年四个季度的开支，看如下程序：

  1. #include <iostream>
  2. #include <string>
  3. #include <array>
  4.  
  5. using namespace std;
  6. const int Seasons = 4;
  7. const array<string,Seasons> Snames = {"Spring","Summer","Fall","Winter"};
  8.  
  9. void fill(array<double,Seasons> *pa);
  10. void show(array<double,Seasons> da);
  11.  
  12. int main(void)
  13. {
  14.     array<double,Seasons> expenses;
  15.  
  16.     fill(&expenses);//把指针填充到array里面
  17.     show(expenses);
  18.  
  19.     return 0;
  20. }
  21. void fill(array<double,Seasons> *pa)
  22. {
  23.     for (int i = 0; i < Seasons; i++)
  24.     {
  25.         cout << "Enter " << Snames[i] << " expensens: ";
  26.         cin >> (*pa)[i];//pa是array对象的指针，需要转化成值再进行操作
  27.     }
  28. }
  29. void show(array<double,Seasons> da)
  30. {
  31.     double total = 0.0;
  32.     cout << "EXPENSENS: " << endl;
  33.     for (int i = 0; i < Seasons; i++)
  34.     {
  35.         cout << Snames[i] << ": $" << da[i] << endl;
  36.         total += da[i];
  37.     }
  38.     cout << "Total expenses: " << total << endl;
  39. }

结果：

Enter Spring expensens: 212
Enter Summer expensens: 256
Enter Fall expensens: 208
Enter Winter expensens: 244
EXPENSENS:
Spring: $212
Summer: $256
Fall: $208
Winter: $244
Total expenses: 920
 

*cin >> (*pa)[i];//pa是array对象的指针，需要转化成值再进行操作

九、递归

C++函数又一个特点——可以自己调用自己（但是C++不允许main()调用自己），这种功能被称为递归。

1：包含一个递归调用的递归

如果递归函数调用自己，则被调用的函数也将调用自己，这将无限循环下去，除非代码又包含终止的内容，一般放在if语句中，如下：void类型的递归函数recurs()代码如下：

  1. void recurs(argumentlist)
  2. {
  3.  
  4.        statements1
  5.        if(test)
  6.             resurs(arguments)
  7.        statements2
  9. }

看如下的例子：

  1. #include <iostream>
  2.  
  3. using namespace std;
  4. void countdown(int n);
  5.  
  6. int main(void)
  7. {
  8.     countdown(4);
  9.     return 0;
  10. }
  11.  
  12. void countdown(int n)
  13. {
  14.     cout << "counting down.... " << n << endl;
  15.     if(n>0)//更新条件，递归退出条件
  16.     {
  17.         countdown(n-1);
  18.     }
  19.     cout << n << ": Kandom" << endl;
  20. }

结果：

counting down.... 4
counting down.... 3
counting down.... 2
counting down.... 1
counting down.... 0
0: Kandom
1: Kandom
2: Kandom
3: Kandom
4: Kandom

*

1）当n递减到0的时候才开始执行下面的代码：cout << n << ": Kandom" << endl;

2）第二个部分将于与函数调用相反的顺序执行5次！

3）每次调用递归都会创建自己的一套变量，因此当程序到第五次调用时，将有5个独立的n变量，其中每个变量的值都不同，对程序如下修改！

  1. #include <iostream>
  2.  
  3. using namespace std;
  4. void countdown(int n);
  5.  
  6. int main(void)
  7. {
  8.     countdown(4);
  9.     return 0;
  10. }
  11.  
  12. void countdown(int n)
  13. {
  14.     cout << "counting down.... " << n << "(n at adress: " << &n << ")" << endl;
  15.     if(n>0)//更新条件，递归退出条件
  16.     {
  17.         countdown(n-1);
  18.     }
  19.     cout << n << ": Kandom" << "(n at adress: " << &n << ")" << endl;
  20. }

结果如下：

counting down.... 4(n at adress: 0x1d3adffc10)
counting down.... 3(n at adress: 0x1d3adffbe0)
counting down.... 2(n at adress: 0x1d3adffbb0)
counting down.... 1(n at adress: 0x1d3adffb80)
counting down.... 0(n at adress: 0x1d3adffb50)
0: Kandom(n at adress: 0x1d3adffb50)
1: Kandom(n at adress: 0x1d3adffb80)
2: Kandom(n at adress: 0x1d3adffbb0)
3: Kandom(n at adress: 0x1d3adffbe0)
4: Kandom(n at adress: 0x1d3adffc10)

2：包含多个递归调用的递归

在需要将一项工作不断分为两项较小、类似的工作，递归很有用。递归方法有时被称为分而治之策略，比如对标尺找到两端，找到终点并标记，然后同样的操作给标尺的左右两部分继续用。

见如下程序：

  1. #include <iostream>
  2.  
  3. using namespace std;
  4. const int Len = 66;
  5. const int Divs = 6;
  6. void subdivide(char ar[], int low, int high,int levels);
  7.  
  8. int main(void)
  9. {
  10.     char ruler[Len];//字符数组
  11.     for(int i = 0; i < Len; i++)
  12.         ruler[i] = ' ';//清空数组
  13.     
  14.     int min = 0; //数组边界开始
  15.     int max = Len - 2; //数组边界结束
  16.     ruler[Len-1] = '\0';
  17.     ruler[min] = ruler[max] = '|';
  18.  
  19.     for(int i = 1; i < Divs; i++)
  20.     {
  21.         subdivide(ruler,min,max,i);//这样使用递归好像就可以了
  22.         cout << ruler << endl;
  23.     }
  24.  
  25.     return 0;
  26. }
  27. void subdivide(char ar[], int low, int high,int levels)//levels是为了控制递归退出
  28. {
  29.     if(levels == 0)
  30.         return;
  31.  
  32.     int mid = (low + high) / 2;
  33.     ar[mid] = '|';
  34.  
  35.     subdivide(ar,low,mid,levels-1);
  36.     subdivide(ar,mid,high,levels-1);
  37. }

结果：

|                               |                               |
|               |               |               |               |
|       |       |       |       |       |       |       |       |
|   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
 

*

1）刚开始是两边两条斜杠，第二次变成三条，第三次变成5条，一直递归下去，

2）将递归次数写进了形参，然后形成判断条件

十、函数指针

与数据项相似，函数也有地址。函数的地址是存储机器语言代码的内存的开始地址。我们可以编写一个将另外一个函数的地址作为参数的函数，这样第一个函数能找到第二个函数并运行，特殊的是，它允许在不同的时间传递不同函数的地址，这意味着可以在不同的时间使用不同的函数

1：函数指针基础知识

比如我们要设计一个estimate()函数来估算指定行数的代码需要的时间，并希望不同的此恒许愿都将使用该函数。我们将程序员要使用的算法函数地址传递给esitmate(),为此必须：

·获取函数地址

·声明一个指针

·使用函数指针调用函数

1)获取函数地址

使用函数名即可，不用参数，比如说think()是函数，则think是该函数的地址

2）声明函数指针

比如：函数如下

double pan(int);则指针如下

double (*pf)(int);

写的时候直接把原型中的函数名用(*Name)替换了就行了

*一定要加（），不然就是函数名

double (*pf)(int);这时函数指针

double *pf(int),这就是一个函数了

                                                                

3）使用指针调用函数

现在(*pf)扮演的角色就与函数名相同，因此使用(*pf)时，可将它看作是函数名即可！

例如：
double pam(int);

double (*pf)（int）;

pf = pam;

2：函数指针示例

下面的程序演示如何使用函数指针，两次调用estimate()函数，依次传递besty()函数的地址，另一次传递pam()函数的地址。如下
 

  1. #include <iostream>
  2.  
  3. using namespace std;
  4. double Rick(int lines);
  5. double Jack(int lines);
  6. void estimate(int lines, double(*pf)(int));
  7.  
  8. int main(void)
  9. {
  10.     int code;
  11.  
  12.     cout << "How many lines of code do you need?\n";
  13.     cin >> code;
  14.  
  15.     cout << "Here is Rick's estimate: " << endl;
  16.     estimate(code,Rick);
  17.  
  18.     cout << "Here is Jack's estimate: " << endl;
  19.     estimate(code,Jack);
  20.     
  21.     return 0;
  22. }
  23. double Rick(int lines)
  24. {
  25.     return lines * 0.05;
  26. }
  27.  
  28. double Jack(int lines)
  29. {
  30.     return (0.03 * lines) + (0.0004 * lines * lines);
  31. }
  32.  
  33. void estimate(int lines, double(*pf)(int))
  34. {
  35.     cout << lines << " Lines code will take " << (*pf)(lines) << " hours." << endl;
  36. }

结果：

How many lines of code do you need?
100
Here is Rick's estimate:
100 Lines code will take 5 hours.
Here is Jack's estimate:
100 Lines code will take 7 hours.

*

可以看到在最后一行代码我们声明了和Rick,Jack类型相同的函数指针*pf，使用的时候直接用名字参数即可： (*pf)(lines) << " hours." << endl;

3：深入讨论函数指针

看下例：

  1. #include <iostream>
  2.  
  3. using namespace std;
  4. const double *f1(const double *ar,int n);
  5. const double *f2(const double ar[],int n);
  6. const double *f3(const double ar[],int n);
  7.  
  8. int main(void)
  9. {
  10.     double av[3] = {1112.3,1542.6,2227.9};
  11.     
  12.     //part1: p1是指向函数的指针
  13.     const double *(*p1)(const double *,int) = f1;//第一种方法，使用传统方法进行给指针赋值
  14.     
  15.     auto p2 = f2; //第二种方法：使用auto方法，让编译器自动判断p2的类型
  16.     
  17.     cout << "PART1:--------------------" << endl;
  18.     cout << "Adress        Value" << endl;
  19.     cout << (*p1)(av,3) << ": " << *((*p1)(av,3)) << endl; //(*p1)(av,3) == f1(av,3),第二个是把该函数内容再显示出来
  20.  
  21.     cout << p2(av,3) << ": " << *p2(av,3) << endl;//第二种方法，直接把指针名称写出来就行了
  22.  
  23.     //part2:  p2是由指针构成的数组
  24.     const double *(*pa[3])(const double *,int) = {f1,f2,f3};//指针数组的内容是函数,注意它的声明方法
  25.     
  26.     auto pb = pa;//这样pb也是函数指针数组
  27.  
  28.     cout << "PART2:--------------------" << endl;
  29.     cout << "Adress        Value" << endl;
  30.     for(int i = 0;i < 3; i++)
  31.         cout << pa[i](av,3) << ": " << *pa[i](av,3) << endl;//pa[1]就是f1了,加*就是它里面的内容
  32.     for (int i = 0; i < 3; i++)
  33.     {
  34.         cout << pb[i](av,3) << ": " << *pb[i](av,3) << endl;
  35.     }
  36.  
  37.     //part3: 
  38.     //(pc)pd 是指针，指向了一个由函数指针构成的数组
  39.     auto pc = &pa;//pc是指向由三个函数指针作为元素的数组pa的指针
  40.     const double *(*(*pd)[3])(const double *,int) = &pa;//传统方法,首先pd是指针，就是*pd,然后*pd是3个元素数组指针，就是*(*pd)[3]，最后每个元素都是函数指针,就有了这个
  41.  
  42.     cout << "PART3:--------------------" << endl;
  43.     cout << "Adress        Value" << endl;
  44.     cout << (*pc)[0](av,3) << ": " << *(*pc)[0](av,3) << endl;
  45.     
  46.     const double *pdb = (*pd)[1](av,3);
  47.     cout << pdb << ": " << *pdb << endl;
  48.  
  49.     cout << (*pd)[2](av,3) << ": " << *(*pd)[2](av,3) << endl;
  50.     cout << (*(*pd)[2])(av,3) << ": " << *(*(*pd)[2])(av,3) << endl;//这两种写法其实是一样的
  51.  
  52.     return 0;
  53. }
  54. const double *f1(const double *ar,int n)
  55. {
  56.     return ar;
  57. }
  58. const double *f2(const double ar[],int n)
  59. {
  60.     return ar + 1;
  61. }
  62. const double *f3(const double ar[],int n)
  63. {
  64.     return ar + 2;
  65. }

结果：
PART1:--------------------
Adress        Value
0xf0e7dff6a0: 1112.3
0xf0e7dff6a8: 1542.6
PART2:--------------------
Adress        Value
0xf0e7dff6a0: 1112.3
0xf0e7dff6a8: 1542.6
0xf0e7dff6b0: 2227.9
0xf0e7dff6a0: 1112.3
0xf0e7dff6a8: 1542.6
0xf0e7dff6b0: 2227.9
PART3:--------------------
Adress        Value
0xf0e7dff6a0: 1112.3
0xf0e7dff6a8: 1542.6
0xf0e7dff6b0: 2227.9
0xf0e7dff6b0: 2227.9

*总结一下

1）

(*pa[2])(av,3) ≠ *pa[2](av,3)，括号优先级不一样

pa[2](av,3)来说，pa[2]是指针数组第三个元素，就是函数指针，最后*，就是第三个函数的值

(*pa[2])(av,3)来说，(*pa[2])就是第三个元素函数指针所指向的函数指针，然后赋值，出来的还是地址

2）

对于函数指针来说*pf和pf其实是等价的

3）

请注意pa和&pa的区别（pa是数组），pa是数组第一个元素的地址，即&pa[0]，而&pa是整个数组（三个指针）的地址，从数字上说它们相同，但是它们类型不同。

比如pa+1是下一个元素的地址，而&pa+1是后面12个字节内存块的地址。

还有个差别，要得到第一个元素的值，只需要对pa解除即可，而&pa解除两次引用

**&pa == *pa == pa[0]

4)

用auto解放了复杂的声明过程

const double *(*pa[3])(const double *,int) = {f1,f2,f3};
    
auto pb = pa;//这样pb也是函数指针数组

5）

还可以用typedef进行简化（并没有定义新的东西，而是起了一个别名，第五章说过）

比如：typedef int n,这里就把n变成int类型了

比如：typedef double real;这里real就变成了double类型了，而不是变量

实例如下:

typedef const double *(*p_fun) (const double *,int)，可以直接用p_fun类型了

p_fun p1 = f1;

p_fun pa[3] ={f1,f2,f3};

十一、复习题和编程练习

1：复习题：

1:使用函数的三个步骤？

定义，调用，声明

2：请创建与下面的描述匹配的函数原型

a:igor()没参数，没返回值

void igor(void);

b:tofu()接收一个int参数，且返回一个float

float tofu(int)

c:mpg()接收两个double，返回一个double

double mpg(double,double)

d:summation()将long数组名和数组长度作为参数，返回一个long

long arr[n];

long summation(long [],int)

e:doctor()接受一个字符串参数（不能修改），并返回double

double doctor(const char *str)

f:ofcourse()将boss结构作为参数，无返回值

void ofcourse(boss bs)  形参名可写可不写

g:plot将map结构的指针作为参数，返回字符串

char *plot(map *pt)

3:编写一个接受3个参数的函数，：int数组名、数组长度、和一个int值 ，并将数组所有元素都设置为该int值

void Set(int ar[], int n, int x)

{

     for(i = 0;i<n;i++)

                 {

                              ar[i] = x;

                }

}

4:编写一个接受三个参数的函数：指向数组区间中第一个元素的指针、指向数组区间最后一个元素后面的指针以及一个int值，并将数组中的每个元素都设置为该int值

  1. void Set(int *begin,int *end , int x)
  2. {
  3.     for (int *pt = begin; pt != end ; pt ++ )
  4.     {
  5.         *pt = x;
  6.     }
  7. }

*注意循环条件

5：编写一个double数组名和数组长度作为参数，并返回该数组中最大值的函数。该函数不应该修改数组内容。

  1. double Set(const double ar[],int len)
  2. {
  3.     double max = arr[0];
  4.     for(int i = 1; i < size; i++)
  5.     {
  6.         if(max < arr[i]);
  7.             max = arr[i];
  8.     }
  9.     return max;
  10. }

6：为什么不对基本类型的函数参数使用const?

我们的C++一般是按值传递参数，而不像数组和结构这种，整体复制，修改副本其实对原来的值不影响，但是如果用指针了就必须加const

7：C++使用哪三种C风格的字符串

char数组。char ch[] = "Hello";

字符串。"hello;";

可以指向字符串首字符的指针。char * pt = "Hello.指的是地址

8：编写一个函数，原型如下：

该函数将字符串中所有的c1都替换为c2,并返回替换次数

int replace(char * str, char c1,char c2)

  1. int replace(char * str,char c1,char c2)
  2. {
  3.     int count;
  4.     while(*str)
  5.     {
  6.         if(*str == c1)
  7.         {
  8.             *str = c2;
  9.             count++;
  10.         }
  11.         str++;
  12.     }
  13.     return count;
  14. }

9：表达式*"pizza"代表：字符串首地址，取出p

"taco[2]"呢，taco是数组，第三个元素，双引号就是首地址

10：C++允许按值传递结构，也允许传递结构的地址。如果glitz是一个结构变量，如何按值传递它？如何传递地址？两种方法有何利弊？

地址传递不能保护原始数据；但是按值传递内存消耗大

11：函数judge()返回类型是int，它将这样一个函数地址作为参数：将const char指针作为参数，并返回int值，写该函数原型

int judge(int (*pf) (const char));

12:结构如下：

struct applicant

{

        char name[30];

        int ratings[3];

}

a:编写一个显示该结构体内容的函数，参数就是结构体

  1. void show(applicant ap)
  2. {
  3.     for (int  i = 0; i < 2; i++)
  4.     {
  5.         cout << ap.name[i] << ap.ratings[i] << endl;
  6.     }
  7.     
  8. }

b.将该结构的地址作为参数，显示参数所指向结构的内容

  1. void show(applicant *ap)
  2. {
  3.     for (int  i = 0; i < 2; i++)
  4.     {
  5.         cout << ap->name << ap->ratings[i] << endl;
  6.     }   
  7. }

13：假设f1()和f2()原型如下：

void f1(applicant * a);

const char * f2(const applicant * a1,const applicant * a2);

1）请将p1和p2分别声明为指向f1和f2的指针；

2）将ap声明为数组，它包含5个类型与p1相同的指针

3）将pa声明为一个指针，它指向的数组包含10个类型与p2相同的指针

使用typedef方法来实现。

1）

  1. typedef void *(pf_1)(applicant * a);//使用typedef直接变成类型
  2. pf_1 p1 = f1;
  3.  
  4. typedef char const char *(*p_f2)(const applicant *a1,const applicant *a2);
  5. p_f2 p2 = f2;

2）pf_1 ap[5];

3p_f2 (*pa) [10];

2：编程练习

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/780985
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号