实验六 函数与编译预处理
函数与编译预处理
函数与编译预处理一、函数的定义1、无参函数的定义形式类型标识符函数名()第一行:函数首部{声明部分语句 { }包含的:函数体}例1:void fun( ){printf(“Hello!\n”);}2、有参函数的定义形式类型标识符函数名(形式参数列表){声明部分语句}例2:int max(int x, int y){ int z;z = x > y ? x : y;return (z);}注:“类型标识符”是指函数值的类型。
若省略,默认为int。
二、函数的调用无参函数:函数名()有参函数:函数名(实际参数列表)例3:在main函数中调用fun和max函数void main( ){int m,n,t;scanf(“%d,%d”,&m,&n);t=max(m,n); /*调用max函数*/fun(); /*调用fun函数*/printf(“max number is %d\n”,t);}注:1、C语言程序由函数构成,其中有且仅有一个main函数,各函数书写的先后顺序任意。
2、函数的定义是相互独立的,不能在一个函数的内部定义另一个函数,即函数的定义不能嵌套。
3、程序从main函数开始执行,其他函数被调用时执行,调用完后回到主调函数,最后在main函数中结束整个程序。
三、函数的声明在主调函数中一般要对被调函数进行声明。
声明的作用是告知编译器被调函数的函数名、函数类型、参数个数和参数类型,方便进行语法检查。
声明的形式:类型标识符函数名(形式参数列表);即:函数首部加分号例如:void fun( );int max(int x, int y);其中参数名称可省略,如:int max(int , int );Turbo C在以下两种情况中,可省略函数声明:1、被调函数定义在主调函数前。
2、被调函数类型为int、char。
四、参数的传递1、形参是变量,但函数被调用时才被分配内存,调用完毕,所占内存将被释放。
实验6 函数与编译预处理(参考答案)
实验六函数与编译预处理(参考答案)[实验任务一]:程序跟踪调试实例6-1:error6_1.c参考答案程序跟踪调试实例6-2:error6_2.c参考答案程序跟踪调试实例6-3:error6_3.c参考答案[实验任务二]:程序填空实例6-1:blank6_1.c参考答案程序填空实例6-2:print1.c参考答案程序填空实例6-3:reverse.c参考答案[实验任务三]:编程实例6-1:primefun.c参考答案(第一种方法)编程实例6-1:primefun.c参考答案(第二种方法)编程实例6-1:primefun.c参考答案(第三种方法)编程实例6-2:printnum.c参考答案编程实例6-3:printa.c参考答案编程实例6-4:power.c参考答案(第一种方法)编程实例6-4:power.c参考答案(第二种方法)编程实例6-5:Taile.c参考答案编程实例6-6:value.c参考答案编程实例6-7:LeRangDe.c参考答案编程实例6-8:multifac.c参考答案[实验任务四]:程序1参考答案:#include <stdio.h>/* 函数功能:计算两整型数之和,如果与用户输入的答案相同,则返回1,否则返回0 函数参数:整型变量a和b,分别代表被加数和加数函数返回值:当a加b的结果与用户输入的答案相同时,返回1,否则返回0 */int Add(int a, int b){int answer;printf("%d+%d=", a, b);scanf("%d", &answer);if (a+b == answer)return 1;elsereturn 0;}/* 函数功能:打印结果正确与否的信息。
函数参数:整型变量flag,标志结果正确与否函数返回值:无*/void Print(int flag){if (flag)printf("Right!\n");elseprintf("Not correct!\n");}main() /*主函数*/{int a, b, answer;printf("Input a,b:");scanf("%d,%d", &a, &b);answer = Add(a, b);Print(answer);}程序两次测试的运行结果分别如下:①Input a,b:1,2↙1+2=3↙Right!②Input a,b:1,2↙1+2=4↙Not correct!程序2参考答案:#include <stdio.h>/* 函数功能:计算两整型数之和,如果与用户输入的答案相同,则返回1,否则返回0 函数参数:整型变量a和b,分别代表被加数和加数函数返回值:当a加b的结果与用户输入的答案相同时,返回1,否则返回0*/int Add(int a, int b){int answer;printf("%d+%d=", a, b);scanf("%d", &answer);if (a+b == answer)return 1;elsereturn 0;}/* 函数功能:打印结果正确与否的信息。
C语言 函数与编译预处理
main() {
int i, m, s=0; for (i=1; i<6; i++)
{ m=mul( i ); s+=fact( m );
} printf(“%d\n”, s); }
函数的递归调用
函数的递归 函数自身
在调用函数的过程中,该函数又去调用 int f (int x)
补充:编写一个函数isprime(int a)用来判断自变 量a是否是素数,若是,返回数值1,否则返回数值0。
开始 输入a, flag=1 调用判断函数
算法思想: 只能被 1 和其本身整
除的数,称为素数
Y
N
是素数?
flag=1
返回
flag=0
查看源程序
补充:利用isprime函数,编程验证任意一个偶数可 以写成两个素数之和。
查看源程序
6.4 函数的嵌套与递归调用
函数的嵌套 在调用函数的过程中,又去调用另一个函数
main()
sub1()
sub2()
例6.6 计算 s = (1*1)!+(2*2)!+(3*3)!+...+(6*6)!
算法分析:n!可定义为一个函数fact( int n ) ( k*k)的运算也可以定义为一个函数mul( int k ) 计算s本身是一个循环程序
int n; scanf( “%d”, &n ); printf(“%d\n”,sum(n)); }
int sum ( int n ) {
int s=0; int k; for( k=1;k<=n; k++)
s= s + k; return s; }
函数与编译预处理实验报告
函数与编译预处理实验报告一、实验目的本次实验旨在通过编写程序,掌握函数与编译预处理的相关知识,了解函数的调用和返回机制以及编译预处理的作用。
二、实验环境操作系统:Windows 10开发工具:Code::Blocks 17.12编程语言:C语言三、实验内容1. 函数的定义和调用函数是C语言中的一个重要概念,它可以将一段代码封装成一个功能单元,方便代码重用和维护。
在本次实验中,我们需要掌握如何定义函数,并且了解函数的调用过程。
在C语言中,函数通常由以下几部分组成:返回类型函数名(参数列表){函数体;return 返回值;}其中,返回类型指定了函数返回值的类型;函数名是唯一标识符,用于调用该函数;参数列表指定了该函数需要传入的参数;函数体是一段具体的代码逻辑;return语句则将结果返回给调用者。
在调用一个函数时,我们需要按照以下格式进行:返回值变量 = 函数名(参数列表);其中,返回值变量接收该函数返回的结果;参数列表则按照定义顺序传入相应参数。
如果该函数不需要传入任何参数,则可以省略参数列表。
2. 函数指针除了直接调用一个已经定义好的函数外,我们还可以使用函数指针来间接调用一个函数。
函数指针和普通指针类似,它指向的是一个函数的地址。
通过函数指针,我们可以在运行时动态地确定需要调用哪个函数。
在C语言中,声明一个函数指针的方法如下:返回类型 (*指针变量名)(参数列表);其中,括号中的*表示这是一个指针变量;指针变量名则是该变量的标识符;参数列表和返回类型与被指向的函数相同。
通过以下代码可以将一个已经定义好的函数赋值给一个函数指针:int max(int a, int b){return a > b ? a : b;}int (*p)(int, int) = max;在上述代码中,p就是一个用于存储max函数地址的函数指针。
3. 编译预处理编译预处理是C语言中一项重要的功能,在编译过程中会对源代码进行一些预处理操作。
C语言程序设计实验报告——实验六
c=add(a,b);
printf("sum is %f\n",c);
}
float add(float x,float y)
{
float z;
z=x+y;
return(z);
}
2.调试运行以下程序,分析调用函数前后程序中变量a和b的值是否发生改变?为什么?
void main( )
{
int a=3,b=6;
/*04*/ {
/*05*/ int a=14, b=15, temp;
/*06*/ temp=a/b;
/*07*/ #ifdef DEBUG
/*08*/ printf("a=%d, b=%d \n", a, b);
/*09*/ #endif
/*10*/ printf("temp =%d \n", temp);
#include <stdio.h>
#define NL printf("\n")
#define PRINT(F,V) printf("V=%F\t",V)
#define PRINT1(F,X1) PRINT(F,X1);NL
#define PRINT2(F,X1,X2) PRINT(F,X1);PRINT(F,X2);NL
main( )
{
int a,b,c,d;
float e,f,g,h;
long i,j;
char n,m;
a=1;b=2;c=3;d=4;e=1.5;f=2.5;g=3.5;h=4.5;
i=10;j=100;n='x';m='y';
c语言 第六章 函数与编译预处理2
#elif和#else可以 #elif和#else可以 没有
如果条件1为真就编译程序段1 如果条件1为真就编译程序段1, 否则如果条件2 否则如果条件2为真就编译程序段 2,…,如果各条件都不为真就编译 #endif必须存在 #endif必须存在,它 必须存在, 程序段n 程序段n。 #if命令的结尾 是#if命令的结尾 #if和#elif常常与 #if和#elif常常与defined命令配合 常常与defined命令配合 使用,defined命令的格式为 命令的格式为: 使用,defined命令的格式为:
预编 译处 理后
a = 3.14; * 2 * 2;
错误! 错误!
宏可以被重复定义 宏可以被重复定义。 重复定义。 #define N 10 /*第一次宏定义 第一次宏定义*/ 第一次宏定义 fun( ) 输出结果: 输出结果: { 2010 printf(“%d”,N ); /* 输出 */ 输出10 } #define N 20 /*第二次宏定义 第二次宏定义*/ 第二次宏定义 void main ( ) { printf ("%d", N ); /* 输出 */ 输出20 fun( ); }
例:下面的程序利用ACTIVE_COUNTRY定义货币的名称 下面的程序利用ACTIVE_COUNTRY定义货币的名称
#define #define #define #define USA 0 ENGLAND 1 FRANCE 2 ACTIVE_COUNTRY USA
#if ACTIVE_COUNTRY == USA char *currency = “dollar”; //有效 //有效 #elif ACTIVE_COUNTRY == ENGLAND char *currency = "pound" ; #else char *currency = "france" ; char *currency = “dollar”; #endif
实验6 函数与编译预处理
实验六函数与编译预处理(4学时)实验前必须做的操作...............——..新建文件夹:1、先在对应的K:盘上建立一个父文件夹(用来存放本人整个学期的作业),格式为:“专业+班级+学号+姓名”,如:工业1091班、学号为05的匡珍春同学,其父文件夹名称为:工业109105匡珍春,然后在此父文件夹下建立子文件夹,名称为:实验6(用来存放实验6需要上交的文件)。
2、在E:盘上建立一个以本人姓名为名称的文件夹(本次实验的工作文件夹),例如:E:\匡珍春【实验目的】1、掌握自定义函数的一般结构及定义函数的方法;2、掌握函数的形式参数、实际参数、函数返回值等重要概念;3、掌握函数实参与形参间的“值传递”方式;4、掌握函数声明、函数调用的一般方法;5、掌握模块化程序设计思想,会采用C语言中函数进行模块化程序设计;6、掌握全局变量和局部变量作用域以及全局变量和局部变量的使用方法;7、掌握函数的嵌套调用的程序的执行过程,会使用嵌套调用设计程序;8、掌握使用函数递归调用的程序的执行过程,会使用递归程序解决实际问题;9、理解宏的概念,掌握宏定义。
了解文件包含的概念,掌握其用法;10、学习对多文件程序的编译和运行;11、熟练掌握VC程序调试方法,包括断点的设置和取消,以及单步执行跟踪进入函数和跳出函数的方法。
【实验内容】[实验任务一]:断点的设置和取消、单步执行跟踪进入函数和跳出函数方法练习程序跟踪调试实例6-1:调试示例(请仔细按以下各步骤进行操作):从键盘输入一个正整数n,计算n! 的值,要求定义和调用函数fact(n),计算n!。
Input n: 1010! = 3628800说明:实验五中我们使用了程序运行到光标位置调试程序,本次实验需要掌握设置断点,以及单步调试进入函数和跳出函数的方法。
【操作步骤】:(1)输入源程序,并以error6_1.c文件名最终保存在实验6文件夹里,编译程序,出现警告信息:双击该警告信息,箭头指向“f=fact(n);”这一行,警告信息指出函数“fact”没有定义,而函数“fact”实际上已经定义了,这是为什么呢?因为函数在调用之前,必须先声明。
实验六 函数与编译预处理
实验六函数与编译预处理1.void main(){float a,b,c;scanf("%f%f",&a,&b);c=add(a,b);printf("sum is %f\n",c);}float add(float x,float y){float z;z=x+y;return(z);}//错误的地方,(1)没有包含头文件<stdio.h> (2)函数定义应该在函数调用的前面. 更正后的程序:#include<stdio.h>float add(float x,float y){float z;z=x+y;return(z);}void main(){float a,b,c;scanf("%f%f",&a,&b);c=add(a,b);printf("sum is %f\n",c);}2.void main(){int a=3,b=6;printf("a=%d,b=%d\n",a,b);exchange1(a,b);printf(:a=%d,b=%d\n",a,b);}void exchange1(int x,int y){int t;t=x;x=y;y=t;printf("x=%d,y=%d\n",x,y);}//错误的地方,(1)没有包含头文件<stdio.h> (2)函数定义应该在函数调用的前面.更正后的程序:#include<stdio.h>void exchange1(int x,int y){int t;t=x;x=y;y=t;printf("x=%d,y=%d\n",x,y);}void main(){int a=3,b=6;printf("a=%d,b=%d\n",a,b);exchange1(a,b);printf("a=%d,b=%d\n",a,b);}3.long int fac(int n){long int p;int i;p=1;for(i=1;i<=n;i++)p=p*i;return(p);}int cmn(int m,int n){int x;x=fac(m)/(fac(n)*fac(m-n));return(x);}void main(){int m,n,c;scanf("%d%d",&m,&n);c=cmn(m,n);printf("c=%d\n",c);}//应该加个#include<stdio.h> 头文件4.int a=7,b=9;void main(){int i,a=5,x=80,y=60;for(i=1;i<4;i++){printf("a=%d,b=5d,max=%d\n",a,b,max(a,b));b+=6;}printf("result_sum=%d\n",sum(x,y));}int sum(int x,int y){extern int m,n;int temp;temp=x+y+m+n+a+b;return(temp);}int m=12,n=25;int max(int 1,int b){return(a>b?a:b);}程序更正:#include<stdio.h>int a=7,b=9;void main(){int i,a=5,x=80,y=60;int max(int a,int b);int sum(int x,int y);for(i=1;i<4;i++){printf("a=%d,b=5d,max=%d\n",a,b,max(a,b));b+=6;}printf("result_sum=%d\n",sum(x,y));}int sum(int x,int y){extern int m,n;int temp;temp=x+y+m+n+a+b;return(temp);}int m=12,n=25;int max(int a,int b){return(a>b?a:b);}5.调试运行以下程序.#include<stdio.h>int fun(int a){int b=0;static int c=2;b+=c;c+=1;return(a+b-c);}void main(){int a=3,i;for(i=0;i<3;i++) printf("%4d",fun(a));}6.略7.略8.#include<stdio.h>#define DEBUGvoid main(){int a=14,b=15,temp;temp=a/b;#ifdef DEBUGprintf("a=%d,b=%d",a,b);#endifprintf("temp=%d\n",temp);}程序结果为:a=14,b=15,temp=0(1)第二行中,宏定义是可以没有具体的值的,在这里只是定义了一个宏名.DEBUG没有值.(2)第7~9行为:#ifdef DEBUGprintf("a=%d,b=%d",a,b);#endif会被编译,因为种种原因DEBUG已经被定义过.(3)如将第2行删除,程序运行结果为:temp=0 因为没有定义DEBUG,所以原来第7~9行的程序没有执行.(4)第9行不能删除,因为#ifdef 和#endif必须成对出现.9.编程题#include<stdio.h>long int fac(int n){long int p;int i;p=1;for(i=1;i<=n;i++)p=p*i;return(p);}void main(){int m,n,c;scanf("%d%d",&m,&n);c=fac(n)/(fac(n-m)*fac(m));printf("c=%d",c);}。
C语言程序设计_06函数与编译预处理
注意:所有的递归问题都一定可以用非递归的算法实现,并 且已经有了固定的算法。如何将递归程序转化为非递归程序 的算法已经超出了本书的范围,感兴趣的读者可以参看有关 数据结构的文献资料。
6.5 变量的作用域与存储类别 6.5.1 变量的作用域 在程序中能对变量进行存取操作的范围称为变量的作用域。 根据变量的作用域不同,变量分为局部变量和全局变量。 1.局部变量 在一个函数体内或复合语句内定义的变量称为局部变量。局 部变量只在定义它的函数体或复合语句内有效,即只能在定 义它的函数体或复合语句内部使用它,而在定义它的函数体 或复合语句之外不能使用它。
(3)将分解后的每个小问题作为一个整体,描述用这 些较小的问题来解决原来大问题的算法。 由第(3)步得到的算法就是一个解决原来问题的递归 算法。由第(1)步将问题的规模缩到最小时的条件就 是该递归算法的递归结束条件。 【例6.7】利用递归函数打印如图6-7所示的数字金字塔 图形。
图6-7 数字金字塔
2.函数体 在函数定义的最外层花括号括起来的部分称作函数体。在函 数体的前面部分可以包含函数体中程序对象的声明和变量定 义,声明和定义之后是描述函数功能的语句部分。 函数体中的RETURN语句用于传递函数的返回值。一般格式 为: RETURN 表达式;
说明: (1)一个函数中可以有多个RETURN语句,当执行到某个 RETURN语句时,程序的控制流程返回调用函数,并将 RETURN语句中表达式的值作为函数值带回。 (2)若函数体内没有RETURN语句,就一直执行到函数体 的末尾,然后返回调用函数。这时也有一个不确定的函数值 被带回。 (3)若不需要带回函数值,一般将函数定义为VOID类型。 (4)RETURN语句中表达式的类型应与函数返回值的类型 一致。不一致时,以函数返回值的类型为准。 3.空函数 C语言还允许函数体为空的函数,其形式为: 函数名() {} 调用此函数时,什么工作也不做。
函数与编译预处理实验报告
函数与编译预处理实验报告1. 背景函数与编译预处理是计算机编程中非常重要的两个概念,它们对于程序的结构和执行效率都起着关键作用。
函数是一段可重复使用的代码块,通过将任务划分为多个函数可以提高代码的可读性与维护性。
而编译预处理则是在编译过程中对源代码进行预处理,包括宏展开、文件包含和条件编译等操作。
本次实验通过设计并实现一段使用函数和编译预处理的程序,旨在加深对函数和编译预处理的理解,掌握它们的基本概念和使用方法,并通过实践感受它们对程序结构和性能的影响。
2. 分析2.1 需求在实验中,我们需要设计一个问题,通过函数和编译预处理来实现对问题的解决。
首先,我们需要确定问题的具体要求和输入输出规范。
只有明确了问题的需求,才能设计出合适的函数和合理的编译预处理指令。
2.2 设计根据实验要求,我们可以设计一个简单的问题:计算一个整数的平方。
用户输入一个整数,程序输出该整数的平方。
这是一个简单的计算问题,可以通过函数和编译预处理来实现。
我们可以设计一个函数calculate_square用于计算平方,并通过编译预处理指令来实现输入输出的控制。
具体的实现细节如下:#include <stdio.h>// 函数:计算平方int calculate_square(int x) {return x * x;}// 编译预处理指令:实现输入输出控制#define ENABLE_INPUT_OUTPUT#ifdef ENABLE_INPUT_OUTPUTint main() {int num;printf("Please enter an integer: ");scanf("%d", &num);int result = calculate_square(num);printf("The square of %d is %d.\n", num, result);return 0;}#endif上述代码中,我们定义了一个函数calculate_square用于计算整数的平方。
d06_函数与编译预处理解读
退出
递归调用
#include <stdio.h> void main() { int x,y,z,n; int max(int a, int b); x=2; y=8; z=-12; //调用max找出x、y、z的最大值 //并赋值给变量n n = max(y, z); n = max(x, n); printf(“最大值是%d\n”,n) } 第六章 函数与编译预处理 int max(int a, int b) { int m; if(a>b) m=a; else m=b; return m; }
(1) 主函数开始执行时,给实际参数分配存 储空存储变量值。 (2) 函数调用时,给形式参数分配空间,实 际参数传值给对应的形式参数。 (3) 实际参数和形式参数占用不同的存储空 间。
//被调用的自定义函数swap void swap(int a,int b) { int temp; if(a<b) { temp=a; a=b; b=temp; } }
分析程序的功能: (1) 输出20个* (2) 计算两数之和 (3) 找出两数之间的大值
第六章 函数与编译预处理
退出
自定义函数
用户根据实际需求先定义函数,然后通过调用执 行函数,实现函数的功能。
运算类函数:为了完成某类运算,函数执行结束 后会得到运算结果,通常需要将这个结果反馈给 调用它的函数。 操作类函数:为了完成某类操作,函数的执行过 程对应一系列操作,这类函数通常不需要产生反 馈结果。
n = max(x, max(y,z));
退出
递归调用prg6-6.c
编程计算n!,其中n从键盘输入。
#include <stdio.h> void main() 如果要求设计自定义函数计算n!, { 程序该如何编写呢? int i,n; long result=1; printf("从键盘输入变量n的值\n"); scanf("%d",&n); for(i=1;i<=n;i++) result=result*i; printf("%d!=%d\n",n,result); } 第六章 函数与编译预处理 退出
第六章-函数与编译预处理命令
2.函数的定义和说明
补充说明: 1. 空函数——既无参数、函数体又为空的函数。 [函数返回值类型] 函数名(void) { } 2. 传统C语言的定义方式 例: double add(x,y) 类型 函数名称(参数表) 参数说明;
double x, y;
3. 如果有参数,则应对它们的类型一一作出说明。
4. 不能在一个函数内部再定义函数
5. 从语法规则上讲,函数类型可以是除函数和数组以外的任何类型 。但对一个具体函数的定义来说,它的类型是惟一的,并且通常 与其返回值的类型一致。如果不一致,系统自动转换。注意,缺 省的函数类型是int型。
2.函数的定义和说明
例: 被调函数,含形参 max(float x, float y) { 1. 注意采用了缺省函数 float z; 类型的定义方式,因此, z=x>y?x:y; 默认返回int型 return z; 2. 即使z是float型, } return语句将把z转化为 调用函数 main() int型,即去掉小数点 { 3. 由于max返回为int型,而c为 float a=1.5,b=0.5; float型,系统直接把max返回的 float c; int型量转换为float型,赋给c 带实参调用 c=max(a,b); printf(“max os %f\n”,c); 注意,由于没有在函数定义时指 } 定函数类型为float型,导致小数 运行结果: 点后的结果出错 Max is 1.000000 改正: float max(float x, float y)
函数的概述
从函数形式的角度进行分类 1. 无参函数:无参函数即在函数定义、函数说明及函 数调用中均不带参数。
2. 有参函数:有参函数也称为带参函数。在函数定义及 函数说明时都有参数,称为形式参数(简称为形参) 。
函数与编译预处理解读
二、标准库函数与自定义函数
C语言有丰富的库函数,这些函数的说明在不 同的头文件(*.h)中。
想要调用标准的库函数,就必须include。
#include<stdio.h> main() {printf(“%d”,1024*768); } 调用printf函数时, 必须include<stdio.h>
返回值
另外请注意这样的判断 最好只使用局部变量,这样将方便调试。 如果不需返回则可 调用函数时输入参数的格式要与之相同 return ,如写成‘ 0; A‟<capital<„Z‟是不行 注意不要与已有库函数重名 的
三、函数定义的一般形式
1、无参函数的定义形式
类型标识符 函数名() { 声明部分 语句 }
26
/★对被调用函数的声明★ /
/ ★函数首部★ / / ★函数体★ /
运行情况如下: 3.6,6.5 sum is 10.000000
27 在函数声明中也可以不写形参名,而只写形参的类型。如: float add(float,float);
在C语言中,以上的函数声明称为函数原型(function prototype)。 它的作用主要是利用它在程序的编译阶段对调用函数的合 法性进行全面检查。 函数原型的一般形式为 ① 函数类型 函数名(参数类型1,参数类型2……)
c=2*max(a,b);
(3)函数参数 函数调用作为一个函数的实参。例如:
m=max(a,max(b,c));
25
4、对被调用函件 (1)首先被调用的函数必须是已经存在的函数(是库函数或用 户自己定义的函数)。
(2)如果使用库函数,一般还应该在本文件开头用#include命 令将调用有关库函数时所需用到的信息“包含”到本文件中 来。例如,前几章中已经用过的 #include <stdio.h>
函数与编译预处理
例6.3 用递归方法计算n!。
long fact(int n) { if(n==0||n==1) return 1; else return n*fact(n-1); } main() { int n; long m; scanf("%d",&n); m=fact(n); printf("%d!=%ld\n",n,m); }
程序举例
1.以下程序的输出结果是 #define M(x,y,z) x*y+z main() {int a=1,b=2,c=3; printf(“%d\n”,M(a+b,b+c,c+a)); }
计算过程: 1+2*2+3+3+1=12
4+4*4+4/2+2*2+2=28
有以下程序执行后输出结果是 #define f(x) x*x main() {int i; i=f(4+4)/f(2+2); printf(“%d\n”,i); }
2.带参数的宏定义
带参数的宏定义的一般形式为: #define 宏名(形参表) 字符串 对带参数的宏,在调用时,不仅要宏展开,而且要用实参去代换形参。 带参数宏调用的一般形式为:宏名(实参表); #define MAX(x,y) x>y?x:y main() { int a,b,m; scanf("%d%d",&a,&b); m=MAX(a,b); printf("max=%d\n",m);
全局变量和局部变量的使用特点 变量存储类别
函数与预编译处理
#include<stdio.h> int max(int x,int y) { return x>y?x:y; } void main() { int a,b,c,m; printf ("请输入3个整数:\n"); scanf("%d%d%d",&a,&b,&c); m=max(c,max(a,b)); printf ("m=%d\n",m); }
【例6.5】 求1!+2!+3!+4!+5!。
#include<stdio.h> /* 不是语句,末尾不加分号 */ int fact(int n) /* 求n!函数 */ { int j,f=1 ; for(j=1;j<=n;j++) f=f*j ; return f; /* 返回main函数 */ } void main() { int k, sum=0 ; for(k=1;k<=5;k++) sum=sum+fact(k); printf("sum=%d\n",sum); }
#include<stdio.h> void main() { float x, y; int n ; float power(float x,int n); /* power()函数的提前声明 */ scanf("%f%d", &x,&n); y=power(x, n); printf("y=%.2f\n", y ); } float power(float x,int n) { int i; float t=1; for(i=1;i<=n;i++) t=t*x; return t; }
函数与编译预处理
,一一传递数据。
2、函数调用的方式
(1)函数语句 printf(“%d”,’3’);
(2)函数表达式 y=power(3,3);
(3)函数参数 函数调用作为一个函数的实参如:
maxval=max(max(a,b),c);
3、 对被调用函数的声明和函数原型
①在一个函数中调用另一函数需要具备的条件:
a、调用的函数必须是已经存在的函数(是库函数或自己定
的参数表称为形式参数表,简称形参表。
★ 说明:函数定义不允许嵌套。
在C语言中,所有函数(包括主函数main()都是平行的。 一个函数的定义,可以放在程序中的任意位置,主函数main() 之前或之后。但在一个函数的函数体内,不能再定义另一个
函数,即不能嵌套定义。
2019/10/10
C语言程序设计教程
第6章 函数与编译预处理 10
3、函数类型与返回值
在C语言中可把函数分为有返回值函数和无返回值函数两种: (1)函数返回值与return语句
有返回值的函数,是通过函数中的return语句来获得的。 ①return语句的一般格式: return ( 返回值表达式 );
②return语句的功能:返回调用函数,并将“返回值表达式”
的值带给调用函数。
例6_2:计算1!+2!+3!+…+10! 的值
void main() {
long mm( int n); int i; long s=0; for (i =1; i <=10; i ++)
s+= mm(i ); printf(“\n%ld”,s); }
long mm( int n) { long t=1; int i;
第6章函数与编译预处理
main() 例 比较两个数并输出大者 { int a,b,c;
scanf("%d,%d",&a,&b);
c=max(a,b); (main 函数) c=max(a,b);
实参
max(int x, int y)(max 函数) printf("Max is %d",c);
a=printstar(); printf("%d",a); }
输出:10
void printstar() { printf("**********"); } main() { int a;
a=printstar(); printf("%d",a); }
编译错误!
上一页
下一页
例 函数返回值类型转换
上一页
下一页
例 交换两个数
swap(int *p1,int *p2) { int p;
调前:
a 5
b 9
p=*p1; *p1=*p2;
p1
a
&a
5
*p2=p; }
调swap:
p2
b
main()
&b
9
{ int a,b;
p1
a
scanf("%d,%d",&a,&b);
&a
9
printf(“a=%d,b=%d\n”,a,b); 交换:
调用函数b
b函数
上一页
下一页
long fac(int k) {long f=1; int i; for(i=1;i<=n;i++)
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验六函数与编译预处理
实验六函数与编译预处理
1.
void main()
{
float a,b,c;
scanf("%f%f",&a,&b);
c=add(a,b);
printf("sum is %f\n",c);
}
float add(float x,float y)
{
float z;
z=x+y;
return(z);
}
//错误的地方,(1)没有包含头文件<stdio.h> (2)函数定义应该在函数调用的前面. 更正后的程序:
#include<stdio.h>
float add(float x,float y)
{
float z;
z=x+y;
return(z);
}
void main()
{
float a,b,c;
scanf("%f%f",&a,&b);
c=add(a,b);
printf("sum is %f\n",c);
}
2.
void main()
{
int a=3,b=6;
printf("a=%d,b=%d\n",a,b);
exchange1(a,b);
printf(:a=%d,b=%d\n",a,b);
}
void exchange1(int x,int y)
{
int t;
t=x;x=y;y=t;
printf("x=%d,y=%d\n",x,y);
}
//错误的地方,(1)没有包含头文件<stdio.h> (2)函数定义应该在函数调用的前面.
更正后的程序:
#include<stdio.h>
void exchange1(int x,int y)
{
int t;
t=x;x=y;y=t;
printf("x=%d,y=%d\n",x,y);
}
void main()
{
int a=3,b=6;
printf("a=%d,b=%d\n",a,b);
exchange1(a,b);
printf("a=%d,b=%d\n",a,b);
}
3.
long int fac(int n)
{
long int p;
int i;
p=1;
for(i=1;i<=n;i++)
p=p*i;
return(p);
}
int cmn(int m,int n)
{
int x;
x=fac(m)/(fac(n)*fac(m-n)); return(x);
}
void main()
{
int m,n,c;
scanf("%d%d",&m,&n); c=cmn(m,n);
printf("c=%d\n",c);
}
//应该加个#include<stdio.h> 头文件
4.
int a=7,b=9;
void main()
{
int i,a=5,x=80,y=60;
for(i=1;i<4;i++)
{
printf("a=%d,b=5d,max=%d\n",a,b,max(a,b));
b+=6;
}
printf("result_sum=%d\n",sum(x,y));
}
int sum(int x,int y)
{
extern int m,n;
int temp;
temp=x+y+m+n+a+b;
return(temp);
}
int m=12,n=25;
int max(int 1,int b)
{
return(a>b?a:b);
}
程序更正:
#include<stdio.h>
int a=7,b=9;
void main()
{
int i,a=5,x=80,y=60;
int max(int a,int b);
int sum(int x,int y);
for(i=1;i<4;i++)
{
printf("a=%d,b=5d,max=%d\n",a,b,max(a,b));
b+=6;
}
printf("result_sum=%d\n",sum(x,y));
}
int sum(int x,int y)
{
extern int m,n;
int temp;
temp=x+y+m+n+a+b;
return(temp);
}
int m=12,n=25;
int max(int a,int b)
{
return(a>b?a:b);
}
5.调试运行以下程序.
#include<stdio.h>
int fun(int a)
{
int b=0;
static int c=2;
b+=c;
c+=1;
return(a+b-c);
}
void main()
{
int a=3,i;
for(i=0;i<3;i++) printf("%4d",fun(a));
}
6.略
7.略
8.
#include<stdio.h>
#define DEBUG
void main()
{
int a=14,b=15,temp;
temp=a/b;
#ifdef DEBUG
printf("a=%d,b=%d",a,b);
#endif
printf("temp=%d\n",temp);
}
程序结果为:a=14,b=15,temp=0
(1)第二行中,宏定义是可以没有具体的值的,在这里只是定义了一个宏名.DEBUG没有值.
(2)第7~9行为:
#ifdef DEBUG
printf("a=%d,b=%d",a,b);
#endif
会被编译,因为种种原因DEBUG已经被定义过.
(3)如将第2行删除,程序运行结果为:temp=0 因为没有定义DEBUG,所以原来第7~9行的程序没有执行.
(4)第9行不能删除,因为#ifdef 和#endif必须成对出现.
9.编程题
#include<stdio.h>
long int fac(int n)
{
long int p;
int i;
p=1;
for(i=1;i<=n;i++)
p=p*i;
return(p);
}
void main()
{
int m,n,c;
scanf("%d%d",&m,&n);
c=fac(n)/(fac(n-m)*fac(m));
printf("c=%d",c); }。