头歌实验1-3c++面向过程程序设计

第1关:最大值函数

本关任务:编写一个能求两个或三个数中最大值的小程序。

为了完成本关任务,你需要掌握:

  • 函数声明与定义;

  • 函数重载;

  • 使用函数。

函数是程序中用于实现某个功能的一小段代码。

  • 函数声明

一个函数的原型声明主要分为3个部分:返回值类型函数名参数列表,表现形式为:

 
  1. <返回值类型> <函数名>(<参数列表>)

例如:

 
  1. //两条函数原型声明
  2. int Func(int a,int b); // 以分号结尾
  3. void Func2();

第一条声明的返回值类型是 int,函数名是 Func,参数列表是int a,int b。第二条声明的返回值类型是 void,即无返回值。函数名是 Func2,参数列表为空,即无参数。

其中,参数列表中的每一个参数被称为形式参数,用于接收调用函数时传递的参数。

  • 函数定义

定义函数实际上就是实现函数功能,语法与函数声明差不多,只是将声明最后的分号换成一块大括号包裹的代码块。

例如:

 
  1. int Func(int a,int b)
  2. {
  3. return a + b; // 返回参数 a 与参数 b 的和
  4. }
  5. void Func2()
  6. {
  7. return; //无返回值,单一个 return,可省略
  8. }

在函数中使用 return 语句能中断函数执行并返回一个值。可以根据需要在多个地方使用 return 语句。返回值不是 void 类型的函数建议在每一个函数执行结束的地方都放上 return 语句,以确保函数的返回值有效。

比如:

 
  1. int Func(int a)
  2. {
  3. if(a > 10)
  4. {
  5. return 10;
  6. }
  7. else
  8. {
  9. /*
  10. 在这里不写 return 语句虽然不会报错,
  11. 但建议还是加上 return 语句
  12. */
  13. }
  14. }

当两个函数名字相同,而参数列表的参数数量、类型或者顺序不同时,这两个函数就是重载函数。需要注意的是,C++ 支持函数重载,但 C 不支持。

例如:

 
  1. //下面 3 个函数则为重载函数
  2. int Add(int a,int b);
  3. int Add(int a,int b,int c);
  4. char Add(char a,char c);

只有返回值不同的两个函数不能作为重载函数,例如:

 
  1. int Add(int a,int b);
  2. char Add(int a,int b); // 只有返回值不同,不能作为重载函数

要调用一个函数,只需要在函数名的后面加上一对圆括号,并在其中加上要传递的参数即可。

例如:

 
  1. int Add(int a,int b)
  2. {
  3. return a + b;
  4. }
  5. int main()
  6. {
  7. int c = Add(10,20); // 调用 Add 函数,传递 10 和 20 作为参数
  8. cout << c << endl;
  9. }

输出结果为:30

调用函数时后面的圆括号中的参数叫做实际参数,它会与函数内的形式参数按照顺序一一对应。

当调用一个重载函数时,编译器会根据参数选择与调用参数最匹配的版本,例如:

 
  1. int Add(int a,int b)
  2. {
  3. cout << "重载1" <<endl;
  4. return a + b;
  5. }
  6. int Add(int a,int b,int c)
  7. {
  8. cout << "重载2" <<endl;
  9. return a + b + c;
  10. }
  11. char Add(char a,char b)
  12. {
  13. cout << "重载3" <<endl;
  14. return a + b;
  15. }
  16. int main()
  17. {
  18. Add(10,20); // 实际调用的是 int, int 那个重载版本函数
  19. Add(10,20,30); // 实际调用的是 int,int,int 那个重载版本函数
  20. Add('a','b'); // 实际调用的是 char,char 那个重载版本函数
  21. }

输出结果为:

 
  1. 重载1
  2. 重载2
  3. 重载3

在右侧编辑器中的Begin-End之间补充代码,设计一个函数 Max,用来求两个或三个数中的最大值。它的两个重载函数的原型如下:

  • int Max(int a,int b)

  • int Max(int a,int b,int c)

注意:平台会组织一些参数调用这两个重载函数,然后将结果输出,你只需补充两个函数即可。

平台会对你编写的代码进行测试,比对你输出的数值与实际正确数值,只有所有数据全部计算正确才能通过测试:

预期输出:

 
  1. 2
  2. 5
  3. 2
  4. 4
  5. 0
int Max(int a,int b)
{
    /********* Begin *********/
    //找出两个参数中最大的那个并返回
   
    return a>b?a:b;

    
    
    /********* End *********/
}

int Max(int a,int b,int c)
{
    /********* Begin *********/
    //找出三个参数中最大的那个并返回
    int Max = a>b ? a:b;
    return Max >c ? Max:c;
    
    
    /********* End *********/
}

第2关:计算阶乘

任务描述

本关任务:编写一个能计算阶乘的小程序。

相关知识

为了完成本关任务,你需要掌握:

  • 递归函数;

  • 头文件与源文件。

递归函数

当一个函数有直接或者间接调用自身的代码,这个函数就是一个递归函数

例如:

 
  1. int Sum(int n)
  2. {
  3. if(n > 0)
  4. return n + Sum(n -1); // 调用自身
  5. return 0;
  6. }
  7. int main()
  8. {
  9. cout << Sum(3) << endl;
  10. }

输出结果为:6

这个递归函数实现了0到 n 的求和,将整个运行过程展开来看的表达式为:3+(2+(1+(0)))。

巧妙的设计递归函数能解决很多复杂的问题,其中的精妙之处在短短的一节中是无法讲清的,所以这里只介绍它的概念,感兴趣的您可以寻找其他资料进行学习。

头文件与源文件

头文件就是源码文件中以“.h”结尾的文件,一般会将函数的原型声明,类的声明,宏定义等声明性的内容放到这一类文件中。

源文件则是以“.cpp”结尾的文件(适用 C 和 C++ ),或是以“.c”结尾的文件(仅适用 C ),一般将函数的定义,类的定义等具体实现的内容放在这一类文件中。

在 C 和 C++ 的程序设计中,一般会将一个功能模块的各种声明放到一个头文件中,然后再对应一个源文件,将功能的具体实现写在其中,需要用到这个模块的时候就 include 模块的头文件

例如下列add.h文件:

 
  1. int Add(int a,int b); // 声明 Add 函数

add.cpp文件:

 
  1. int Add(int a,int b) // 实现 Add 函数的功能
  2. {
  3. return a + b;
  4. }

main.cpp文件:

 
  1. #include "add.h" // 引用头文件
  2. int main()
  3. {
  4. int b = Add(10,20); // 使用 Add 函数
  5. }

有些时候一个头文件会被到处使用,为了防止函数或者类等内容的重复声明,一般会在头文件中使用防止重复声明。

例如add.h文件:

 
  1. #ifndef ADD_H_ // 判断存不存在宏定义 ADD_H_,相当于 if 语句
  2. #define ADD_H_ // 不存在则定义 ADD_H_
  3. int Add(int a,int b);
  4. #endif // if 块结束
编程要求

在右侧编辑器中的Begin-End之间补充代码,设计一个函数int Fact(int n),它返回 n 的阶乘(n!)。具体要求如下:

  1. 要求使用递归实现。

  2. 要求这个函数的原型声明与定义分别放在fact.h文件和fact.cpp文件中。

注意:评测的代码会使用 include 命令引用fact.h头文件,请确保 fact.h 文件实现正确。并保证测试代码时 n! 的结果不会超出 int 的表示范围。

测试说明

平台会对你编写的代码进行测试,比对你输出的数值与实际正确数值,只有所有数据全部计算正确才能通过测试:

测试输入:5 预期输出:120

测试输入:8 预期输出:40320


int Fact(int n)
{
    /********* Begin *********/
    //使用递归计算 n 的阶乘
    int f;
    if( n==0||n==1)
    f= 1;
    else
    f=Fact(n-1)*n;
    return f;
   
    
    
    /********* End *********/
}

第3关:求矩阵最大元素

任务描述

本关任务:编写一个能求出矩阵最大元素的小程序。

相关知识

为了完成本关任务,你需要掌握数组的声明和使用。

数组

数组是一种连续存储的数据结构。声明数组,只需在声明变量的基础上,在变量名的后面加上一对方括号([]),然后在其中填上元素数量即可。

例如:

 
  1. int a[10]; // 声明一个有 10 个 int 元素的数组
  2. char b[1]; // 声明一个有 1 个 char 元素的数组

在声明数组的同时,可以使用花括号({})对其进行初始化,例如:

 
  1. int a[2] = {1,2}; // 有两个元素的数组,分别为 1 和 2

花括号中的实际元素数量可以少于方括号中指定的数量,这样的话没有被指定的元素将会是这种类型的默认值,例如:

 
  1. int a[3] = {1}; // 只指定了第一个元素,其他的都是默认值 0,即{1,0,0}

如果使用了花括号进行初始化,那么方括号中的元素数量也可以不写,编译器会根据花括号中的元素数量自动计算,例如:

 
  1. int a[] = {1,2}; // 编译器自动计算为 int a[2]
  2. char b[] = {0}; // 编译器自动计算为 char b[1]
二维数据

二维数组本质上是以数组作为数组元素的数组,即“数组的数组”。二维数组又称为矩阵,行列数相等的矩阵称为方阵。

二维数组的声明与一维数组的声明同理,只需在变量名后面加多个方括号就行。

例如:

 
  1. int a[3][2]; // 可以看做是 3 个元素的数组,每个元素是一个 2 个元素的数组

二维数组也可以用花括号进行初始化,不过它的用法就更为灵活了,例如:

 
  1. int a[3][2] = {{1,1},{2,2},{3,3}};
  2. /*
  3. 嵌套花括号,内部的一个花括号代表 a 数组的一个元素,即:
  4. {1,1}
  5. {2,2}
  6. {3,3}
  7. */
  8. int b[3][2] = {1,2,3};
  9. /*
  10. 平铺成一个 6 个元素的数组,即:
  11. {1,2}
  12. {3,0}
  13. {0,0}
  14. */
数组的使用

要访问数组的某个元素,只需在数组变量的后面加上方括号,在方括号中填上从0开始的索引即可。

例如:

 
  1. int a[5];
  2. a[0] = 1; // 访问数组第一个元素,索引为 0
  3. a[1] = a[0]; // 访问数组第二个元素,索引为 1

二维数组也是同理:

 
  1. int a[3][2];
  2. a[0][0] = 1;
  3. a[1][0] = 2;
  4. a[0][1] = 2;

与普通变量不同的是,数组变量之间不能赋值,但是可以将数组变量赋值给它的类型退化成的指针类型。所谓退化,就是将数组最左边一个维度变成指针(也可以说是指向第一个元素的指针)。

例如:

 
  1. int a[2]; // 一维数组,退化后成 int* 类型
  2. int *aptr = a; // 正确
  3. int b[3][2]; // 二维数组,退化后是int (*)[2],即指向一个 2 个元素的数组的指针
  4. int (*bptr)[2] = b; // 正确
  5. int (*bptr2)[3] = b; // 错误,bptr2 的类型是指向一个 3 个元素的数组的指针

但当数组作为函数的参数类型时,编译器会将它变成它的退化类型,因此只要退化后的类型相同的数组变量都可以传递给这个参数,例如:

 
  1. void F(int a[2])
  2. {}
  3. void F2(int a[3][2])
  4. {}
  5. int main()
  6. {
  7. int a[3],b[5];
  8. F(a); // 正确,退化后的类型相同
  9. F(b); // 正确,退化后的类型相同
  10. int c[4][2],d[5][2];
  11. F2(c); // 正确,退化后的类型相同
  12. F2(d); // 正确,退化后的类型相同
  13. }

既然编译器会退化数组类型,那么参数声明中最左边一个维度的数量也就可以省略了,上面的函数 F ,F2 可以写成如下方式:

 
  1. void F(int a[]) // 不写数量
  2. {}
  3. // 或者直接写成指针 void F(int *a){}
  4. void F2(int a[][2])
  5. {}
  6. //或者 void F2(int (*a)[2]){}
编程要求

在右侧编辑器中的Begin-End之间补充代码,补充函数int MaxEle(int a[3][2],int *r,int *c),函数的功能是找出并返回矩阵 a(一个3行2列的矩阵)中最大的元素,并将它的行、列号通过后两个指针参数 r ,c 返回。

注意:行、列号均从 1 开始。同时,为了结果稳定,矩阵中保证不会有相同元素。

测试说明

平台会对你编写的代码进行测试,比对你输出的数值与实际正确数值,只有所有数据全部计算正确才能通过测试:

测试输入:1 2 3 4 5 6 预期输出:6 3 2

测试输入:9 2 3 4 5 6 预期输出:9 1 1


int MaxEle(int a[3][2],int *r,int *c)
{
    /********* Begin *********/
    //返回最大元素和它所在的行、列号
    


    int i,j;
    int max=0;
        for(i=0;i<3;i++){
        for(j=0;j<2;j++)
        {
            if (a[i][j]>max)
            {
                max= a[i][j];
            *r=i+1;
            *c=j+1;
            }
        }
        }
        
        return max;


    
    

    
    
    /********* End *********/
}

第4关:打印空心菱形图案

任务描述

本关任务:编写一个以链表为基础的学生信息管理小程序。

相关知识

为了完成本关任务,你需要掌握:

  • 多重循环结构;

  • 函数定义与调用。

测试说明

平台会对你编写的代码进行测试,比对你输出的数值与实际正确数值,只有所有数据全部计算正确才能通过测试:

测试输入:

 
  1. 14

预期输出:

 
  1. *****************************
  2. *************  *************
  3. ************   ************
  4. ***********    ***********
  5. **********     **********
  6. *********      *********
  7. ********       ********
  8. *******        *******
  9. ******         ******
  10. *****          *****
  11. ****           ****
  12. ***            ***
  13. **             **
  14. *              *
  15. **             **
  16. ***            ***
  17. ****           ****
  18. *****          *****
  19. ******         ******
  20. *******        *******
  21. ********         ********
  22. *********      *********
  23. **********      **********
  24. ***********     ***********
  25. ************   ************
  26. *************  *************
  27. *****************************

预期输出说明:平台评测执行顺序为先插入测试输入的数据,再删除第2组数据,最后打印结果。

#include<iostream>
using namespace std;
void diamond(int n, char op, char cfill);

int main()
{
	int n ;
	cin >> n;
	diamond(n, '*', ' ');
}

/********* Begin *********/
   
    void diamond(int n, char c1, char c2)
{
    int i, j;
 
for (i = 0; i < n; i++) 
{
cout << "\n";
for (j = 1; j <= n -i; j++)
cout << c1;
for (j = 1; j <= 2 * i - 1+1; j++) 
cout << c2;
for (j = 1; j <= n - i; j++)  
cout << c1;
}

for (i = n-2; i >= 0; i--)
{
cout << "\n";
for (j = 1; j <=n -i; j++)
cout << c1;
for (j = 1; j <= 2 * i - 1+1; j++)
cout << c2;
for (j = 1; j <= n - i; j++)
cout << c1;
 }
cout << endl;
}


    
    
/********* End *********/

  • 2
    点赞
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
### 回答1: c是一种编程语言,由美国计算机科学家Dennis M. Ritchie在20世纪70年代所开发。c语言设计灵活,功能强大,被广泛应用于操作系统、编译器、数据库管理系统、网络程序等领域。c语言具有高效、兼容性好、可移植性高等特点,是许多计算机科学专业的必修课程。c语言的编码方式具有高度自由度,在使用时要注意语法规范。虽然c语言比较容易学习,但要想掌握它必须付出充分的时间和精力。在c语言的学习过程中,要特别注意实践操作和编程习惯。c语言可以很好地锻炼编程思维和逻辑能力,同时也为其他编程语言的学习打下了良好的基础。通过学习c语言,能够更好地理解计算机底层原理,对于从事计算机开发工作的人员来说,具有重要的意义。c语言在计算机应用领域中的广泛应用,使其成为程序员必须掌握的一门语言。 ### 回答2: 抱歉,无法回答,因为"c"没有给出任何的背景和语境,无法确定您需要回答的问题是什么。请提供更多信息,以便我能够为您提供有意义的答案。 ### 回答3: c是一种计算机编程语言,也被称为“C语言”。它是由贝尔实验室的丹尼斯·里奇(Dennis Ritchie)在1972年开发的,是一种面向过程的编程语言。C语言是一种非常流行的编程语言,广泛应用于软件开发、操作系统、嵌入式系统等领域。 C语言具有以下几个特点: 1. C语言是一种高级语言,但是它可以直接访问计算机硬件,所以可以编写高效的程序。 2. C语言有复杂的控制结构和丰富的数据类型,可以支持各种编程方法和算法。 3. C语言是跨平台的,可以在不同的操作系统上运行。 4. C语言是一种灵活的语言,可以通过库函数和外部程序扩展功能。 在编写C语言程序时,开发者需要注意以下几点: 1. C语言中变量的定义要在函数头部之前,变量的作用域也要注意。 2. C语言使用指针来访问内存地址,开发者需要非常小心地使用指针。 3. C语言中数组的下标从0开始计数,而不是从1开始。 4. C语言是一种比较底层的语言,开发者需要对计算机体系结构有基本的了解。 总之,C语言是一种非常重要的编程语言,既具有高效性又灵活性。尽管它已经存在了几十年,但它仍然是程序员学习的必修课程,是编写高性能软件的重要工具。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值