精华内容
下载资源
问答
  • 张玉生《C语言程序设计实训教程》双色版 配套实验书的答案,纯手打,已经在本地编译环境成功运行后再发布,有错的话请在评论区不吝指正。
    实验10.1
    //求任意两个正整数的最小公倍数
    #include <stdio.h>
    
    int gbs(int m, int n)
    {
    	int r, p;
    	p = m * n;
    	while ((r = m % n) != 0)
    	{
    		m = n;
    		n = r;
    	}
    	p = p / n;
    	return(p);
    }
    
    int main()
    {
    	int a, b, c;
    	printf("Enter two integers: ");
    	scanf("%d%d", &a, &b);
    	c = gbs(a, b);
    	printf("c=%d\n", c);
    
    	system("pause");
    	return;
    }
    
    实验10.2
    //输入m和n(m>=1,n<=100),输出m`n之间的完数:因子和它本身相等的数
    #include <stdio.h>
    
    int factsum(int n);	//对函数进行声明
    
    int main()
    {
    	int i, m, n, result;
    	printf("Enter two integer numbers m and n: ");
    	scanf_s("%d%d", &m, &n);
    	if (m > n)
    	{
    		i = m; m = n; n = i;	//使m<n
    	}
    	for (i = m; i <= n; i++)
    	{
    		result = factsum(i);
    		if (i == result)	//判断是否是完数
    			printf("%d\n", i);
    	}
    
    	system("pause");
    	return;
    }
    
    int	factsum(int n)	//求因数和余数
    {
    	int i, sum;
    	sum = 1;
    	for (i = 2; i <= (n / 2); i++)	//找出所有因子
    		if (n % i == 0)				//累加因子
    			sum = sum + i;			//返回因子和
    	return sum;
    }
    
    
    
    实验10.3
    //输入一个正整数n,以每行3个的形式输出小于n的所有素数
    #include <stdio.h>
    
    int prime(int m)
    {
    	int i;
    	for(i=2;i<m-1;i++)	//判断素数
    		if(m%i==0)
    			return(0);
    	return (1);			//是素数,返回1
    }
    int main()
    {
    	int i ,n, k=0;
    	printf("Enter a integer:");
    	scanf("%d",&n);
    	for(i=2;i<=n;i++)
    		if(prime(i))		//调用函数判断素数
    		{
    			printf("%4d",i);
    			k++;
    			if(k%3==0)		//换行
    				printf("\n");
    		}
    
    	printf("\n");
    	system ("pause");
    	return;
    }
    
    实验10.4
    //求出score数组中十个元素的平均值、最大值和最小值
    #include<stdio.h>
    float max = 0, min = 0;//全局变量
    float average(float array[], int n)
    {
    	int i;
    	float aver, sum = array[0];
    	max = min = array[0];//初始化最大最小值
    	for (i = 1; i < n; i++)
    	{
    		if (array[i] > max)//找出最大值
    			max = array[i];
    		else if (array[i] < min)//找出最小值
    			min = array[i];
    		sum = sum + array[i];
    	}
    	aver = sum / n;
    	return aver;
    }
    int main()
    {
    	float ave, score[10];
    	int i;
    	for (i = 0; i < 10; i++)
    		scanf("%f", &score[i]);
    	ave = average(score, 10);//调用函数
    	printf(" max=%.0f\n min=%.0f\n average=%.2f\n", max, min, ave);
    
    	system("pause");
    	return 0;
    }
    
    实验10.5
    //寻找:百位数为0,去掉百位数0可得到一个三位正整数,而该三位正整数乘以9等于原四位正整数 的数
    #include<stdio.h>
    int fun(int n)
    {
    	int a, b, c, d;
    	a = n / 1000;
    	b = (n / 100) % 10;
    	c = (n - a * 1000 - b * 100) / 10;
    	d = n % 10;
    	if ((b == 0) && ((a * 100 + c * 10 + d) * 9 == n))
    		return 1;
    	else
    		return 0;
    }
    
    
    int main()
    {
    	int i;
    	for (i = 1000; i < 10000; i++)
    		if (fun(i))
    			printf("%6d", i);
    	printf("\n");
    
    	system("pause");
    	return 0;
    }
    
    实验10.6
    #include<stdio.h>
    
    int prime(int n)//判断n是否为素数
    {
    	int i;
    	for (i = 2; i < n - 1; i++)
    		if (n % i == 0)
    			return 0;
    	return 1;
    }
    
    int main()
    {
    	int m, n, k=0, flag;
    	for (n = 2; n < 2000; n++)
    		if (prime(n) == 0)//若不是素数则判断下一个
    			continue;
    		else
    		{
    			m = n;
    			flag = 1;//标志变量变为一
    			while (m>0)
    			{
    				m = m / 10;//依次去掉一位数字
    				if (!prime(m))
    				{
    					flag = 0;//若不是素数标志变量置为0
    					break;
    				}
    			}
    			if (flag)//若是素数则输出
    			{
    				printf("\t%d", n);
    				k++;
    				if (k % 5 == 0)
    					printf("\n");
    			}
    
    		}
    	printf("\n");
    	system("pause");
    	return 0;
    
    }
    
    实验10.7
    //输出1~100各位数乘积大于各位数和的数
    #include<stdio.h>
    
    int func(int n)
    {
    	int k = 1, s = 0, m = n, t;
    	while (m)
    	{
    		t = m % 10;
    		k = k * t;
    		s = s + t;
    		m = m / 10;
    	}
    	if (k > s)
    		return 1;
    	else
    		return 0;
    }
    
    int main()
    {
    	int l = 0;
    	for (int num = 1; num <= 100; num++)
    	{
    		if (func(num))
    		{
    			printf("\t%d", num);
    			l++;
    			if (l % 5 == 0)
    				printf("\n");
    		}
    
    	}
    	printf("\n");
    	system("pause");
    	return 0;
    }
    
    
    实验10.8
    //验证哥德巴赫猜想:任何充分大的偶数都可以由两个素数之和来表示
    #include <stdio.h>
    #include <math.h>
    
    int isprime(int n)
    {
    	if (n == 1)
    		return 0;
    	for (int i = 2; i <= n - 1; i++)
    	{
    		if (n % i == 0)
    			return 0; //不是素数返回0
    	}
    	return 1;
    }
    void print_prime(num)
    {
    	int n = num;
    	for (int i = 2; i <= sqrt(n) + 1; i++)
    	{
    		if (isprime(i) && isprime(n - i))//都是素数,则打印
    		{
    			printf("%d = %d + %d\n", n, i, n - i);
    			break;
    		}
    	}
    }
    int main()
    {
    	for (int x = 4; x <= 20; x++)
    		print_prime(x);
    
    	system("pause");
    	return 0;
    }
    
    
    实验10.9
    //输出100以内的正整数包含3,5,7中的一个的数.
    #include <stdio.h>
    
    int func(int n)
    {
    	int x1, x2;
    	x1 = n % 10;//个位
    	x2 = n / 10;//十位
    	if (n == 3 || n == 5 || n == 7)
    		return 1;
    	else if (x1 == 3 || x1 == 5 || x1 == 7 || x2 == 3 || x2 == 5 || x2 == 7)
    		return 1;
    	else
    		return 0;
    }
    
    int main()
    {
    	int l = 0;
    	for ( int num = 1; num < 100; num++)
    	{
    		if (func(num))
    		{
    			printf("\t%d", num);
    			l++;
    			if (l % 5 == 0)
    				printf("\n");
    		}
    	}
    	printf("\n");
    	system("pause");
    	return 0;
    }
    
    
    实验11.1
    //用递归的方法求前n项和
    #include <stdio.h>
    
    int main()
    {
    	int n,s;
    	printf("请输入n的值:");
    	scanf("%d",&n);
    	s=sum(n);
    	printf("%d",s);
    
    	printf("\n");
    	system ("pause");
    	return;
    }
    
    int sum(int n){
    	if(n==0)
    		return 0;
    	else
    		return n+sum(n-1);
    }
    
    实验11.2
    //用递归的方法逆序输出一个整数
    #include <stdio.h>
    
    int main()
    {
    	void printn(int x);
    	int n;
    	scanf("%d",&n);
    	if(n<0)
    	{
    		n=-n;
    		putchar('-');
    	}
    	printn(n);		//调用函数
    
    	printf("\n");
    	system ("pause");
    	return;
    }
    
    void printn(int x)
    {
    	if(x>=0&&x<=9)
    		printf("%d",x);
    	else
    	{
    		printf("%d",x%10);
    		printn(x/10);			//将除去个位的数字作为新的整数继续递归
    	}
    }
    
    实验11.3
    //用递归的方法输出10行杨辉三角
    #include <stdio.h>
    
    int main()
    {
    	int yang(int x,int y);
    	int i,j,k;
    	for(i=1;i<=10;i++)
    	{
    		for(j=0;j<30-2*i;j++)
    			printf(" ");		//打印行首空格
    		for(k=1;k<=i;k++)
    			printf("%4d",yang(i,k));
    		printf("\n");
    	}
    
    	printf("\n");
    	system ("pause");
    	return;
    }
    
    int yang(int x,int y)
    {
    	int z;
    	if(y==1||y==x)					
    		z=1;
    	else
    		z=yang(x-1,y-1)+yang(x-1,y);
    	return z;
    }
    
    实验11.4
    //输出一个不小于n的最小Fibonacci数
    #include <stdio.h>
    #include <math.h>
    
    int fib(int n)
    {
    	int f;
    	if(n==0||n==1)
    		f=1;
    	else
    		f=fib(n-1)+fib(n-2);
    	return f;
    }
    
    
    int main()
    {
    	int i,m,result;
    	printf("Please input a natural number:");
    	scanf("%d",&m);
    	i=1;
    	while((result=fib(i))<m)
    		i++;
    	printf("Meet the conditions of the Fibonacci number is: %d \n",result);
    
    	system ("pause");
    	return;
    }
    
    
    实验11.5
    //重排数组元素,偶数放在数组左边,奇数放在数组右边
    #include <stdio.h>
    
    void judge1(int* b, int n)
    {
    	int i, j, k, temp;
    	for (i = 0, j = n - 1; i < j;)
    	{
    		if ((b[i] % 2) == 1)//若是奇数,则将其移到右部
    		{
    			for (k = i; k < j; k++)
    			{
    				temp = b[k + 1];
    				b[k + 1] = b[k];
    				b[k] = temp;
    			}
    			j--;	//奇数移到右部后,将下标-1
    		}
    		else
    			i++;	//若是偶数,则将下标+1
    	}
    }
    
    int main()
    {
    	int a[10] = { 21,34,224,25,367,41,736,37,42,456 }, i;
    	for (i = 0; i < 10; i++)
    		printf("%5d ", a[i]);
    
    	judge1(a, 10);	//调用函数重新排序
    	printf("\n");
    	for (i = 0; i < 10; i++)
    		printf("%5d ", a[i]);
    	printf("\n");
    
    	system("pause");
    	return 0;
    }
    
    
    实验11.6
    //使用递归函数求整数x和y的最大公约数
    #include <stdio.h>
    int gcd(int x, int y);
    void main()
    {
    	int x, y, z;
    	scanf("%d%d", &x, &y);
    	z = gcd(x, y);
    	printf("%d\n", z);
    
    	system("pause");
    	return 0;
    }
    int gcd(int x, int y)
    {
    	if (y == 0)
    		return x;
    	if (x < y)
    		return gcd(y, x);
    	if (x % y == 0)
    		return y;
    	return gcd(y, x % y);
    }
    
    实验11.7
    //使用递归函数求x的n次方
    #include <stdio.h>
    int a(int x, int n)
    {
        if (n == 0)
            return  1;
        else
            return a(x, n - 1) * x;
    }
    int main()
    {
        int x, n;
        printf("请输入x和n\n");
        scanf("%d%d", &x, &n);
        printf("结果是:%d\n", a(x, n));
    
        system("pause");
        return;
    }
    
    
    展开全文
  • 相信很多人都听说过函数式编程,提到函数程序设计,脑海里涌现出来更多的是Lisp、Haskell等语言,而C#,似乎我们并不把它当成函数式语言,其实,函数程序设计并不是只针对某个特定的程序设计语言,而C#,也正一...

    相信很多人都听说过函数式编程,提到函数式程序设计,脑海里涌现出来更多的是Lisp、Haskell等语言,而C#,似乎我们并不把它当成函数式语言,其实,函数式程序设计并不是只针对某个特定的程序设计语言,而C#,也正一步步使用函数式丰富自己的语言结构,帮助人们更好的实现期望的结果。

    函数式程序设计

    函数式程序设计把重点放在函数的应用上,函数式程序设计人员以函数为基本模块来建立新函数,这并不是说没有其他语言的成分,而是说函数是程序体系创建的主要构造。

    引用透明(Referential transparency)是函数式程序设计领域中的一个重要思想。一个引用透明的函数的返回值只取决于传递给它的参数的值。这正好与指令程序设计的基本思想相反。在指令程序设计中,程序的状态通常会影响函数的返回值。引用透明的函数的数学意义仅存在于函数式程序设计中,这样的函数称为纯函数,没有副作用。

    函数式程序设计属于一种定向思维。如果我们愿意按某种方式去思考,则它可以给我们提供有趣的解决方案或者至少思考的源头,它们都与当前程序设计的许多实际问题有关。

    C#无法做到像Lisp、Haskell或同属于.NET平台的F#那样很容易实现函数式程序设计,这点我们必须承认,但从各方面来讲,用C#实现函数式程序设计确实是有意义的。

    C#函数式程序设计基础之函数与方法

    由于C#的函数只能出现在类中,因此它们通常被称为方法。方法可以接受若干个参数,并且可以有一个返回值。

    与许多面向对象语言一样,C#类中的方法可以是实例方法,也可以是类方法。而在纯函数式程序设计中,没有类,也没有类的实例——当然,有很多方法保存数据,但通常不是用类来保存数据,它们总是在许多方面表现出不同。

    在面向对象环境中,所有其他元素只能出现在类和对象的内部(对象是类实例的另一个说法);而在函数式程序设计中,所有其他元素都出现在函数内部。有些数据保存在函数的局部变量中,就像C#那样定义在方法内部的变量,但这并不是保存数据最理想的方法。

    F#把类级别的成员当成全局成员,同时由于得到特殊语法的支持,程序员不需要考虑实际发生的“转换”过程,遗憾的是,在C#中无法实现这一点,但是解决方法是一样的。

    为了调用全局级的函数(或者任何其他作用域的函数),必须在类内创建类级别的成员。这些成员要用static关键字。由于它们都封装在类中,因此类中的成员有不同的可见度。大多数函数式设计环境都有不同的封装级别——如模块级或命名空间级——因此除了C#中一些比较复杂的语法外,实际上两者没有多大的区别。

    有些函数式语言使用顶级函数或者允许导入模块或命名空间,这样就不需要函数调用的修饰符:

    1
    DoSomething"string paramers"

    在C#中,这样的调用总是需要一个修饰符,即类名,除非这个函数出现在同一个类的内部:

    1
    SomeClass.DoSomething("string paramers");

    C#函数式程序设计基础之重用函数

    在计算机程序设计中,重用是一个非常重要的综合问题。函数并不是可重用性的唯一方法,特别在面向对象程序设计中,很快出现了其他方法。作为C#的一个内置功能,它只支持函数的重载作为函数级模块化的直接办法,C#4.0支持命名参数和可选参数,因此重载函数的解析过程变得相当复杂,特别当它与其他相关方法(如在方法调用时进行泛型类型推断)一起使用时。

    下面举一个重载方法的简单例子:

    int Add(int x, int y)
            {
                return x + y;
            }
    
            int Add(int x, int y,int z)
            {
                return Add(x, y) + z;
            }
    
            double Add(double x, double y)
            {
                return x + y;
            }
    
            double Add(double x, double y, double z)
            {
                return Add(x, y) + z;
            }


    在这个例子中,我们很清楚地看出为什么重载与重用有关:它允许程序员创建与原函数类似的新函数,同时尽可能利用原函数已有的功能。

    C#函数式程序设计基础之匿名函数与Lambda表达式

    并非所有的函数都重要到需要一个名称,一般而言,这些函数并不是类级别的函数,它们没有名称,这些函数的引用地址保存在变量中,因此只要有这些函数的引用地址就可以调用它们。

    从技术上讲,匿名函数肯定要受到某些限制。很遗憾的是,其中之一就是它们不可以是泛型,它们也不可以用来实现迭代器。除此之外,匿名函数几乎可以包括所有做任何“正常”方法可以做的事情。

    static void AnonymousMethods()
            {
                BubbleSorter.IsAGeaterThanBDelegate compareInt =
                    delegate(object a, object b)
                    {
                        return ((int)a) > ((int)b);
                    };
            }


    以上是C#2.0的代码,可以看出,关键字delegate委托代替了方法名。参数列表和方法体还是与前面一样。这个匿名方法也可以改写成如下形式,这里用了C#3.0的Lambda表达式语法:

     BubbleSorter.IsAGeaterThanBDelegate compareInt2 =(object a, object b) => { return ((int)a) > ((int)b); };

    这段代码较短,因为少了delegate关键字,方法体已经写成一行格式。Lambda表达式中的主体=>运算符右侧的部分。可以采取若干方法进一步简化代码。首先, 可以省略参数类型,因为编译器可以根据委托类型的声明语句推断出参数的类型:

    BubbleSorter.IsAGeaterThanBDelegate compareInt2 =(a, b) => {return ((int)a) > ((int)b); };

    其次,由于函数除了返回一个值外不执行任何操作,因此可以把函数体转换为表达式体,并且可以利用隐式返回:

    BubbleSorter.IsAGeaterThanBDelegate compareInt2 =(a, b)=>(int)a) > ((int)b);

    表达式体很有用。因为有了它,在函数式程序中本来需要用函数实现的某个操作现在可以简化为一个表达式。与函数一样,表达式体也要接受参数并返回一个值。表达式体不可以包含任何与返回值求值无关的代码(即只要有一个返回值就行,遗憾的是,经常在表达式体中使用没有返回值的表达式)。

    前面的例子如果使用其中一个泛型委托类型,就可以变成如下的形式:

    Func<object,object,bool> compareInt3=(a, b) => ((int)a) > ((int)b);

    这个委托需要接受两个object类型的参数,返回一个bool值。使用泛型委托类型的另一个好处是,它们的参数类型更容易看明白,因为它们在委托类型中采用显式声明,而且编译器可以为Lambda表达式推断出它们的类型。

    使用Lambda表达式时,有一个细节需要牢记:只有当所有类型都确定后,编译器才会根据几个比较复杂的准则进行类型推断。编译器并不是总能正确地推断出类型,因此,如果所有的类型都确定了,编译器的要求就满足了:

    Func<int,int,int> add =(a, b) => a + b;

    在这个Lambda表达式中不可以使用var关键字,C#中,编译器必须能够在声明的位置推断出参数的类型,对于下面的语句则无法推断出参数的类型:

    var add =(a, b) => a + b;

    函数式程序设计语言要求,在所有与类型推断有关的情形中都需要像这样的显式说明。这在某些C#程序员看来是遗憾的。

    BubbleSorter.IsAGeaterThanBDelegate compareInt2 =(object a, object b) => { return ((int)a) > ((int)b); };

    这段代码较短,因为少了delegate关键字,方法体已经写成一行格式。Lambda表达式中的主体=>运算符右侧的部分。可以采取若干方法进一步简化代码。首先, 可以省略参数类型,因为编译器可以根据委托类型的声明语句推断出参数的类型:

    BubbleSorter.IsAGeaterThanBDelegate compareInt2 = (a, b) => { return ((int)a) > ((int)b); }; 

    其次,由于函数除了返回一个值外不执行任何操作,因此可以把函数体转换为表达式体,并且可以利用隐式返回:

    C#函数式程序设计基础之扩展方法

    扩展方法是静态类中用特殊方法表示的静态方法:

    namespace CompanyWideTools
    {
        public static class StringHelper
        {
            public static string ConCat(this string[] strings, string separator)
            {
                bool first = true;
                var builder = new StringBuilder();
                foreach (var s in strings)
                {
                    if (!first)
                        builder.Append(separator);
                    else
                        first = false;
                    builder.Append(s);
                }
                return builder.ToString();
            }
        }
    }

    表示Concat是一个扩展方法的标志是在该方法的参数列表中使用this关键字。这个关键字是C#专有的,用于命令编译器给这个方法中增加ExtensionMethodAttribute属性。可以像调用静态方法那样调用扩展方法:
    string[] strings = new[]
                 {
                     "to","be","or","not","to","be"
     };

    Console.WriteLine(StringHelper.ConCat(strings," "));    
    然而,由于它是扩展方法,因此也可以像下面这样调用:

    Console.WriteLine(strings.ConCat(""));
    当我们需要充分利用扩展方法的优点时,这种调用方法比较简单。

    每个扩展方法都有一个可扩展的特定类型:第一个参数的类型,即用this标志的那个参数。这个标志只可以用于第一个参数,不可以用于其他参数。扩展方法的第一个参数可以是一个基类类型或者一个接口,甚至可以是System.Object中的对象。扩展方法也可以是泛型的,他们可以扩展泛型类型。

    展开全文
  • C++程序设计 重载函数

    千次阅读 2020-01-26 03:19:40
    编写4个重载函数,分别求整数和字符的最小值(10分) 题目 编写四个重载函数函数求对应参数中的最小值并返回该值。 四个函数的原型是: char min( char c1, char c2 ); char min( char c1, char c2, char c3 ); ...

    编写4个重载函数,分别求整数和字符的最小值(10分)

    题目

    编写四个重载函数,函数求对应参数中的最小值并返回该值。

    四个函数的原型是:

    char min( char c1, char c2 );
    char min( char c1, char c2, char c3 );
    int min( int i1, int i2);
    int min( int i1, int i2, int i3);

    在主函数中定义一些变量并赋初值(使用C++11的auto或者列表初始化方法)

    用第1个 min 函数比较字符 ‘[’ 和字符 ‘N’ 并输出较小的字符;

    用第2个 min 函数比较字符 ‘G’ 、字符 ‘9’ 和字符 ‘*’ 并输出较小的字符;

    用第3个 min 函数比较整数 -42 与 0 并输出较小的整数 (注意第一个整数是负值)

    用第4个 min 函数比较整数 42 、0 和 std::numeric_limits::min() 并输出较小的整数

    std::numeric_limits::min() 是C++系统头文件中的成员。所以你编写代码时需要包含这个头文件。

    由于中国大学MOOC的OJ系统使用的是GCC4.7这个古老的编译器,因此,你不能在声明变量的时候同时使用auto和列表初始化,否则这个编译器会报告很多错误。

    也就是,你不能写类似下面的代码:
    auto x {1}, y{2}; cout << min(x, y);

    emmm,我不管了,这份代码没过oj

    输入格式:

    输出格式:

    用单个空格分隔开的4个数据

    输入样例:

    输出样例:

    N * -42 -2147483648

    注意:上述输出样例中,结尾没有空格,也没有换行符

    注意:

    在C++标准库头文件中,有一套 min()和max()函数。你在编程序时,不要包含该头文件,也不要使用

    using namespace std;

    这种会污染当前代码默认名字空间的语句

    #include <iostream>
    #include <limits>
    
    char min(char c1,char c2);
    char min(char c1,char c2,char c3);
    int min(int i1,int i2);
    int min(int i1,int i2,int i3);
    
    int main()
    {
        std::cout << min('[','N') << " "
                  << min('G','9','*') << " "
                  << min(-42,0) << " "
                  << min(-42,0, std::numeric_limits<int>::min());
        return 0;
    }
    char min(char c1, char c2)
    {
        return c1 > c2 ? c2 : c1;
    }
    char min(char c1,char c2,char c3)
    {
        return c1 > min(c2,c3) ? min(c2,c3) : c1;
    }
    int min(int i1,int i2)
    {
        return i1 > i2 ? i2 : i1;
    }
    int min(int i1,int i2,int i3)
    {
        return i1 < min(i2,i3) ? i1 : min(i2,i3);
    }
    
    
    展开全文
  • 请问windows程序设计中如何修改textmetric函数中前七个参数的值,请知道的告诉下,谢谢了
  • 【C语言】C语言程序设计函数

    千次阅读 2021-02-28 10:25:03
    C语言程序设计(第六周):函数

    本课程来自中国大学MOOC中《C语言程序设计精髓》 (哈尔滨工业大学)

      本讲将介绍一些关于函数的基础知识:

    1. 函数的调用

      在程序设计中,使用函数有利于模块化编程。函数需要经过定义后才能调用,下面仅介绍一下函数调用的过程。
      每次执行函数调用时,有:

    1. 进行现场保护并为函数内的局部变量(包括形参)分配内存
    2. 把实参值复制一份给形参,单向传值(实参 → 形参)
    3. 实参与形参的数目、类型和顺序要一致

      从函数退出时 ,有:

    1. 根据函数调用栈中保存的返回地址,返回到本次函数调用的地方
    2. 把函数值返回给主调函数,同时把控制权还给调用者
    3. 收回分配给函数内所有变量(包括形参)的内存

      举个例子,下面函数的功能是计算平均值:

    #include <stdio.h>
    float Average(int x, int y) ;           /* compute average */
    
    int main()
    {
        int a, b ;
        scanf("%d %d",&a, &b) ;
        printf("avg = %.2f", Average(a, b)) ;
        return 0 ;
    }
    
    float Average(int x, int y)
    /* compute average of x and y */
    {
        float avg ;
        avg = (x + y) / 2.0 ;
        return avg ;
    }
    
    1 2
    avg = 1.50
    

      在主函数main()中,利用Average()函数计算平均值,在控制的传递过程中,首先执行函数main()中的语句,执行到Average()函数处时,将控制传递至Average()函数,并为其分配空间,然后便执行Average()函数中的语句,之后从Average()函数返回,将控制传递给主函数main(),最后函数运行结束。在整个过程中,有函数参数函数控制流以及函数返回值的传递,本质上看,函数的调用也是控制流改变的一种方式,同选择、循环结构有一定的相同之处。

    2. 断言以及程序的安全

      对于程序设计而言,程序的效率高很重要,但是程序的正确性则更为重要,因为错误的程序无论效率多高都无法得到正确的结果。

    2.1 断言

    void assert (int expression);
    Evaluate assertion
    If the argument expression of this macro with functional form compares equal to zero (i.e., the expression is false), a message is written to the standard error device and abort is called, terminating the program execution.

      断言assert()<assert.h>中定义的宏,使用该宏时,则会检测expression的真假:

    1. expression为真,无声无息;
    2. expression为假,中断程序。

      可以认为其相当于if(!expression) exit(1) ;下面给出一个例子:

    #include <stdio.h>
    #include <assert.h>
    int main()
    {
        int x, y ;
        scanf("%d %d",&x, &y) ;
        assert(y != 0) ;                             /* if y == 0, exit . */
        printf("%.2f\n", (float)x/y ) ;
        return 0 ;
    }
    
    1 0
    Assertion failed: y != 0, file :\Documents\Desktop\myproject\Cstudy\Cprogram\main.c, line 7
    

      虽然这样可以禁止y == 0的情况,但assert()仅用于调试程序,不能作为程序的功能,故建议使用assert()的情况有以下几种:

    1. 检查程序中的各种假设的正确性
    2. 证实或测试某种不可能发生的状况确实不会发生

      如下面的情况:

    int MakeNumber(void)
    {
    	int number;
    	number = rand() % 100 + 1;
    	assert(number >= 1 && number <= 100);
    	return number;
    }
    

      值得注意的是,assert()在函数的调试阶段起作用:

    1. Debug版本
      用于内部调试——assert是仅在Debug版本中起作用
    2. Release版本
      发行给用户使用——编译器会跳过assert不生成检查代码

    2.2 程序的安全性

      程序的安全性是一个大的主题,在此,我们考虑下面的例子来介绍它:
      交换两个值,下面有两种方法:

    /* method 1 */
    t = a ;
    a = b ;
    b = t ;
    
    /* method 2 */
    a = a + b ;
    b = a – b ;
    a = a – b ; 
    

      已知的结论是method 1是优于method 2的,那么请问method 2有什么问题?欢迎在评论区讨论!

    3. 编程测验

    1.三位阶乘和数

    题目内容
      假设有这样一个三位数m,其百位、十位和个位数字分别是a, b, c,如果m = a!+b!+c!,则这个三位数就称为三位阶乘和数(约定0!=1)。请编程计算并输出所有的三位阶乘和数。
     函数原型: long Fact(int n);
     函数功能:计算n的阶乘

    #include <stdio.h>
    long Fact(int n) ;
    int main()
    {
        int m, a, b, c ;
        for(m=100; m<1000; m++)
        {
            a = m / 100 ;               /* the hundreds place of m */
            b = (m / 10) % 10 ;         /* the tens place of m */
            c = m % 10 ;                /* the ones place of m */
            if(m == (Fact(a)+Fact(b)+Fact(c)))
            {
                printf("%d\n", m) ;
            }
        }
        return 0 ;
    }
    long Fact(int n)
    /* compute factorial of n */
    {
        long sum = 1 ;
        int i ;
        for(i = n; i >= 1; i--)
        {
            sum *= i ;
        }
        return sum ;
    }
    
    145
    
    展开全文
  • 9 、功能化程序设计方法与函数      函数的作用:  1、函数具备了一定功能,我们无需实现只需调用;  2、代码得到了复用性;  3、让代码具备模块化特性。  函数可以进行值传递和地址传递。  函数的...
  • 回到课程主页,链接:C++程序设计课程主页-2012级 本次上机对应的教学内容:第4章 递归函数、变量的作用域、存储类型第一部分 练习+上机验证(不必提交上机报告) 阅读下列程序,写出程序的运行结果。上机时运行...
  • 递归函数论与程序设计的关系

    千次阅读 2009-11-29 21:54:00
    递归函数论与程序设计的关系(刘爱贵 高能物理研究所计算中心 北京 2003年)摘要: 递归函数论是元计算机科学理论基础,它与计算机科学的实践紧密相关。递归思想影响了程序设计语言的构造,甚至影响了计算机系统结构...
  • 模块化程序设计函数与方法

    千次阅读 2015-12-19 17:53:32
    理解模块化程序设计方法 掌握函数的定义、调用方法 @函数的分类 ;一种是系统提供的标准函数,另一种就是用户自己定义的函数 函数的定义的格式为:  函数类型 函数名称(形式参数表){  说明语句序列  可执行语句...
  • 函数就是一段具有特定功能的、被封装的、可重用的程序。主要还是以例进行学习。 1、输入圆形的半径,得出相应的圆的面积。 少量的几个半径,其实你可以将代码重复的赋值几次代码就行了。但是为了代码的简洁,你...
  • C语言程序设计--函数和程序结构

    千次阅读 2013-10-04 12:19:24
    ANSI表征对C语言所作的最明显的修改是函数声明与函数定义这两个方面。当然,这也只能从宏观上讲解其中的奥妙。 在这里使用了getline函数 int getline(char s[],int lim) { int c,i; while(--lim>0&&(c=getchar...
  • 其实上面的重点是 .type print_fun, @function ,这是定义函数的方式,后面一般接着是函数入口地址标识符; 函数传参问题: 在as汇编和C语言中函数调用时传参的标准是使用堆栈来操作的,而有些其他汇编(如:ARM...
  • 在C语言中,由于C语言的函数库不太强大,如果把所有的程序代写在一个主函数中,会使主函数变得很长,不容易理解和发现错误,因此我们可以用“组装”的方法来使我们的代码变得更整洁美观,这就是模块化程序设计。...
  • 函数程序设计为什么至关重要

    千次阅读 2014-08-08 18:31:34
    Why Functional Programming Matters 函数程序设计为什么至关重要 作者: John Hughes 原文地址:http://www.md.chalmers.se/~rjmh/Papers/whyfp.html 此论文作于1984年,作为查麦兹大学的备忘录流传了多年...
  • 贺老师教学链接 C语言及程序设计提高 本课讲解我们写过这样的程序#include int main() { int iChioce; do { printf("* 1. 吃饭\n"); printf("* 2. 睡觉\n"); printf("* 3. 打豆豆\n"); printf("* 0. 退
  • Tags:《C语言程序设计》读书笔记《C语言程序设计》读书笔记(四)——函数与程序结构book4.1 找出某一字符串在一段文本内的位置并返回 int strindex(char s[], char t[]) { int i,j,k; for(i = 0;s[i] != '\0';i++...
  • 1、 Python中定义函数的关键字是() (def) 2、 在函数内部可以通过关键字()来定义全局变量。 global 3、 如果函数中没有return语句或者return语句不带任何返回值,那么该函数的返回值为 None 4、 表达式 sum(range...
  • 4.1 函数的基本知识 如果函数定义中省略了返回值类型,则默认为int类型。 练习4-1 编写函数strindex(s, t),它返回字符串t在s中最右边出现的位置。 如果s中不包含t,则返回-1。 答: #include int ...
  • 程序设计(Python)实验八 函数

    千次阅读 2021-01-12 02:45:28
    实验八 函数实验目的实验内容练习一题目代码练习二题目代码练习三题目代码练习四题目代码 实验目的 掌握函数的定义与调用过程 掌握参数的传递方式和传递过程 理解和使用匿名函数 理解递归调用的思想和方法 掌握变量...
  • 返回:贺老师课程教学链接(1)若输入的值是 -125,写出下面程序的运行结果。#include #include void fun (int n) { int k,r ; for (k=2; k(n); k++) { r = n % k ; while (!r) { printf("%d
  • 模块化程序设计方法与函数

    千次阅读 2014-09-23 22:03:02
    在C语言的程序设计时,通常将一个大的程序功能分成若干个较小的模块,每个模块编写成结构
  • 程序设计中,在划分模块时要求模块的“内聚性”强、与其他模块的“耦合性”弱,即模块的功能要单一(不要把许多互不相干的功能放到一个模块中),与其他模块的相互影响要尽量少,而用全局变量是不符合这个原则的。...
  • 返回:贺老师课程教学链接 C语言及程序设计初步 C语言的数学库函数提供了大多数常用的数学功能。使用下面的函数,要求程序前写预处理命令:#include以sin函数为例,说明其用法。"double sin(double);意味着参数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 61,377
精华内容 24,550
关键字:

函数程序设计