0%

发表于 分类于

1.主函数已知，编写一个函数实现将整型数组中的偶数删除，然后输出改变后的数组。

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
28
29
30
31
32
33
34
35
36
37
#define MAXSIZE 1024
#include <stdio.h>
int  main()
{
    int a[MAXSIZE],n,i;
    printf("请输入元素个数：\n");
    scanf("%d",&n);
    for ( i = 0; i < n; i++)
    {
        scanf("%d",&a[i]);
    }
    n=hs(a,n);
    for (i = 0; i < n; i++)
    {
        printf("%d ",a[i] );
    }
}

int hs(int a[],int n);

int hs(int a[],int n){
    int b[MAXSIZE];int i=0,j=0;
    for ( i=0,j=0; i < n; i++)
    {
        if (a[i]%2!=0) {
            b[j]=a[i];
            j++;
        }
        
    }
    for (int i = 0; i < j; ++i)
    {
        a[i]=b[i];
    }
    return j;

}

发表于 分类于

#1.宏编程1

定义一个带参数的宏MAXD，计算从键盘输入两个数值中的最大值

1
2
3
4
5
6
7
8
9
#include "stdio.h"
#define MAXD(x,y) x>y?x:y
int main()
{
    int x,y;
    scanf("%d%d",&x,&y);
    printf("%d\n",MAXD(x, y));
    
}

2.宏编程2

定义一个带参数的宏，用来判断整数n是否能被5和7同时整除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include "stdio.h"
#define Zhengchu(n) n%5==0&&n%7==0?1:0
int main()
{
    int n,result;
    scanf("%d",&n);
    result=Zhengchu(n);
    if (n==0) {
        printf("不能整除\n");
    }
    else{
        printf("能被整除\n");
    }
    
}

发表于 分类于

结构体

访问结构体成员

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include "stdio.h"
#include "string.h"
struct Students{
    char Name[20];
    double ID;
} sd1={"Python",1};
int main()
{
    printf("%sID:%.0lf",sd1.Name,sd1.ID);
    printf("\n");
}
/*输出结果为
 PythonID:1
 */

将结构体传给函数

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
28
29
30
31
32
33
	#include "stdio.h"
#include "string.h"
struct Students{
    char Name[20];
    double ID;
} ;
void happy(struct Students sd);
int main()
{
    struct Students sd1;//声明sd1，类型为Studens
    struct Students sd2;
    /*详述sd1*/
    strcpy(sd1.Name, "Pyhton");
    sd1.ID=1;
    /*详述sd2*/
    strcpy(sd2.Name, "C");
    sd2.ID=2;
    /*传递*/
    happy(sd1);
    happy(sd2);
    
    
    
}
void happy(struct Students sd)
{
    printf("(%s)ID:%0.lf",sd.Name,sd.ID);
    printf("\n");
}
/*输出结果：
 (Pyhton)ID:1
 (C)ID:2
 */

指向函数的指针

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
28
29
30
31
32
33
34
#include "stdio.h"
#include "string.h"
struct Students{
    char Name[20];
    double ID;
} ;
void happy(struct Students *sd);
int main()
{
    struct Students sd1;//声明sd1，类型为Studens
    struct Students sd2;
    /*详述sd1*/
    strcpy(sd1.Name, "Pyhton");
    sd1.ID=1;
    /*详述sd2*/
    strcpy(sd2.Name, "C");
    sd2.ID=2;
    /*传递*/
    happy(&sd1);
    happy(&sd2);
    
    
    
}
void happy(struct Students *sd)
{
    printf("(%s)ID:%0.lf",sd->Name,sd->ID);
    printf("\n");
}
/*输出结果：
 (Pyhton)ID:1
 (C)ID:2
 */
//注意和传递结构体给函数的区别

发表于 更新于 分类于

指针练习题(实验10)

基础

5 、编写一个函数，判断任意输入的字符串中，有多少个字母。建议函数原型: int CountNumofLetter(char *string) ;

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
28
29
#include "stdio.h"
#include "string.h"
int CountNumofLetter(char *string);
int main()
{
    char zfc1[]="Everyday*)^&(^i?a{}new one!";
    char zfc2[]="fsiayud^&(%^*$%*$";
    char *p1,*p2;
    p1=zfc1;p2=zfc2;
    printf("\"%s\"中字母的个数为：%d\n",zfc1,CountNumofLetter(p1));
    printf("\"%s\"中字母的个数为：%d\n",zfc2,CountNumofLetter(p2));
   
    
}

int CountNumofLetter(char *string){
    int geshu=0;
    unsigned long i=0;
    for (i=0; i<strlen(string)-1; i++) {
        if ((*(string+i)>='A'&&*(string+i)<='Z')||(*(string+i)>='a'&&*(string+i)<='z')) {
            geshu++;
        }
    }
    return geshu;
}
/*输出结果为：
 "Everyday*)^&(^i?a{}new one!"中字母的个数为：16
 "fsiayud^&(%^*$%*$"中字母的个数为：7
 */

进阶

1 、如下函数: strcpy(char *to ， char *from) 将字符串from复制到字符串 to. 将函数补充完整并实 现在主程序中的调用。void strcpy(char *to ，char *from) {while (____) ; }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include "stdio.h"
#include "string.h"
void str_cpy(char *to,char *from){//因为strcpy会发生冲突，所以中间加了下划线区分
    while (*from!='\0') {//执行循环知道from字符串末尾
        *to=*from;
        to++;from++;    //to和from指针依次递增l；
    }
}
int main()
{
    char yuanshi[]="Today is a good day!";
    char gengxin[]="";
    char *p1,*p2;       //定义两个字符型指针
    p1=yuanshi;p2=gengxin;//字符型指针分别指向两个字符数组的首地址
    str_cpy(gengxin, yuanshi);//调用str_cpy函数
    unsigned i=0;
    for (i=0; i<=strlen(gengxin)-1; i++) {//执行循环，输出新的字符串
        printf("%c",*(p2+i));
    }
}
/*输出结果为：
Today is a good day!
 */

2 、如下函数: merge(int a[] ， int n ， int b[] ， int m ， int *c) 是将两个从小到大有序数组， a 和 b 复制合并出一个有序整数序列 c ，其中形参 n 和 m 分别是数组 a 和 b 的元素个数 . 将函数补充完整并实现在主程序中的调用。

原代码:

1
2
3
4
5
void merge(int a[] ，int n， int b[] ， int m ， int *c) {
int i ， j ;
for (i=j=0; i<n&&j<m ; )   *c++=a[i]<b[j]?a[i++]:b[j++];
while (____________) *c++=a[i++] ;
while (____________) *c++=b[j++] ; }

答案为：

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
28
29
30
31
32
#include "stdio.h"
#include "string.h"
void merge(int a[],int n,int b[],int m,int *c){
    int i,j;
    for (i=j=0; i<n&&j<m;){
        *c++=a[i]<b[j]?a[i++]:b[j++];}
        while (i<n){*c++=a[i++];}
        while (j<m){*c++=b[j++];}
}
int main()
{   int n=5,m=3;//测试1
    int numbers1[]={21,23,24,25,26};
    int numbers2[]={12,13,20};
    int numbers3[8];
    merge(numbers1, n, numbers2, m, numbers3);
    for (int i=0; i<(m+n); i++) {
        printf("%d ",numbers3[i]);
    }
    printf("\n");
    n=5;m=5;//测试2
    int numbers4[5]={1,3,4,8,10};
    int numbers5[5]={-12,-10,22,100,10000};
    int numbers6[10],*p=numbers6;
    merge(numbers4, n, numbers5, m, p);
    for (int i=0; i<(m+n); i++) {
        printf("%d ",p[i]);
    }
}
/*输出结果：
 12 13 20 21 23 24 25 26
 -12 -10 1 3 4 8 10 22 100 10000 Program ended with exit code: 0
 */

3 、有一字符串，包含n(n<=1024)个字符，写一函数，将此字符串中从第m个字符开始的全部字符 复制成为另一个字符串。建议函数原型:void Mystrcpy(char *src， char *des， int m) ;

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
28
29
30
31
32
33
34
35
36
37
//实验10 进阶3/
#include "stdio.h"
#include "string.h"
void Mystrcpy(char *src,char *des,int m);
int main()
{   //测试1
    char yuanshi[]="abcdefghijk";
    char gengxin[]="";
    int m=3;
    char *p1;
    p1=yuanshi;
    char *p2=gengxin;
    Mystrcpy(p1,p2, m);
    //测试2
    char yuanshi1[]="The joy of living never comes to the frivolous,the superficial,the selfish.";
    char gengxin2[]="";
    int n=5;
    char *p3,*p4;
    p3=yuanshi1;p4=gengxin2;
    Mystrcpy(p3, p4, n);
    
        

}
void Mystrcpy(char *src,char *des,int m)
{   char *p3;
    p3=&src[m-1];
    int i=0;
    for (i=0; i<strlen(p3)+1; i++) {
        *(des+i)=*(p3+i);
    }
    printf("%s\n",des);
}
/*输出结果为：
 cdefghijk
 joy of living never comes to the frivolous,the superficial,the selfish.
 */

6 、定义一个具有n(n<=1024)个元素的一维整型数组，编写函数，将其中最小的数与第一个数对换。 建议函数原型:void MinChange(int *data ,int len);

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
28
29
30
31
32
33
34
//实验10 进阶6/
#include "stdio.h"
#include "string.h"
void MinChange(int *data ,int len);//函数声明
int main()
{   //测试1
    int num[]={1,23,32,-29,4,4};
    int len=sizeof(num)/sizeof(int);//获取整型数组的长度
    MinChange(num, len);            //函数调用
    //测试2
    int num1[]={0,5*2,-1*10,234,25*25};
    len=sizeof(num1)/sizeof(int);
    MinChange(num1, len);
}
void MinChange(int *data ,int len){
    int i=0,j=0,mix=data[0],exchange;
    for (i=0; i<len; i++) {//执行循环m，找到最小数和它的下标
        if (mix>data[i]) {
            mix=data[i];
            j=i;
        }
    }
    exchange=data[0];   //交换最小数和第一个数
    data[0]=mix;
    data[j]=exchange;
    for (i=0; i<len; i++) {//循环输出数组
        printf("%d ",data[i]);
    }
    printf("\n");
}
/*输出结果是：
 -29 23 32 1 4 4
 -10 10 0 234 625
 */

14、编程实现字符串比较函数: int MyStrcmp(char *p1，char *p2)。其中，p1和p2分别指向两个字符 串，如果这两个字符串相当则函数返回 0 ，如果这两个字符串不相等则返回二者第一个不同字符的ASCII 差值。例如:“asd”和“ awe” 第二个字符不同，则返回:’s’-‘w’=115-119 = -4

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
28
29
30
31
32
33
34
35
36
37
#include "stdio.h"
#include "string.h"
int MyStrcmp(char *p1,char *p2);
int main()
{   //测试1
    char zf1[]="When love beckons you,follow him,though this way are hard and steep.";
    char zf2[]="When love beckons you,follow him,though this way are hard and steeps.";
    char *p1=zf1,*p2=zf2;
    printf("The results is:%d\n",MyStrcmp(p1, p2));//调用函数并输出返回值
    //测试2
    char zf3[]="abcdefghigkl";
    char zf4[]="abcdefghigkl";
    char *p3=zf3,*p4=zf4;
    printf("The results is:%d\n",MyStrcmp(p3, p4));
    
    
}

int MyStrcmp(char *p1,char *p2){
    int i=0,jieguo=0;
    unsigned long changdu=strlen(p1);//获取字符数组的长度，这里选择p1和p2都是一样的，因为若两个字符数组相同的话长度肯定是一样的
    for (i=0; i<changdu; i++) {//循环判断每一个字符是否相等
        if (p1[i]==p2[i]) {//如果相等，就让jieguo的值一直为0，这样是为了方便函数返回
            jieguo=0;
        }
        else{
            jieguo=p1[i]-p2[i];//如果不相等，就让jieguo=两个zifu的ASCII码的差值
            break;//并且r退出循环
        }
    }
    
    return jieguo;
}
/*输出结果是：
 The results is:-69
 The results is:0
 */

发表于 分类于

C指针

为什么学习指针

通过指针，可以简化一些C编程任务的执行，还有一些任务，如动态内存的分配，没有指针是无法执行的。

什么是指针

指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，使用指针存储其他变量地址之前，需要对其进行声明，

指针的简单使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//指针学习
#include "stdio.h"
int main()
{
   /*指针的简单使用*/
    int number=20;/*实际变量的声明*/
    int *num;/*指针变量的声明*/
    num=&number;/*在指针变量中存储number的地址*/
    printf("number的地址是L：%p\n",num);//两种打印number地址的方式
    printf("number的地址是L：%p\n",&number);
    printf("number的s值是:%d\n",*num);//两种打印number值的方式。
    printf("number的s值是:%d\n",number);
    
    
}
/*输出结果为：
 number的地址是L：0x7ffeefbff4ec
 number的地址是L：0x7ffeefbff4ec
 number的s值是:20
 number的s值是:20
 */

C中的NULL指针

在变量声明的时候，如果没有确切的地址可以赋值，为指针变量赋一个 NULL 值是一个良好的编程习惯。赋为 NULL 值的指针被称为空指针。

在大多数的操作系统上，程序不允许访问地址为 0 的内存，因为该内存是操作系统保留的。然而，内存地址 0 有特别重要的意义，它表明该指针不指向一个可访问的内存位置。但按照惯例，如果指针包含空值（零值），则假定它不指向任何东西。

1
2
3
4
5
6
7
8
9
10
11
12
13
//检查一个空指针
#include "stdio.h"
int main()
{
    int *Zero =NULL;
    if (!Zero) {
        printf("这是一个空指针\n");
    }
    
}
/*输出结果为：
 这是一个空指针
 */

指针的算术运算

指针的递增递减

我们喜欢在程序中使用指针代替数组，因为变量指针可以递增，而数组不能递增，数组可以看成一个指针常量。下面的程序递增变量指针，以便顺序访问数组中的每一个元素：

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
28
29
30
31
32
33
#include "stdio.h"
int main()
{
    //定增一个指针
    int number[4]={5,2,1,1314};
    int *num=number;
    int i=0;
    while (i<=3) {
        printf("number存储值为：%d\n",*num);
        i++;
        num++;
    }
    //递减一个指针
    int number1[4]={1,2,3,4};
    int *num1=&number1[3];//这里注意递减时指针的指向是不一样的
    int j=3;
    while (j>=0) {
        printf("number1存储值为：%d\n",*num1);
        j--;
        num1--;
    }
    
}
/*输出结果为：
 number存储值为：5
 number存储值为：2
 number存储值为：1
 number存储值为：1314
 number1存储值为：4
 number1存储值为：3
 number1存储值为：2
 number1存储值为：1
 */

指针的比较

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include "stdio.h"
int main()
{
    //通过指针的比较来输出数组中的字符
    int number[4]={5,2,1,1314};
    int *num=number;
    int i=0;
    while (num<=&number[3]) {
        printf("number[%d]:%d\n",i,*num);
        i++;
        num++;
    }
}
/*输出结果为：
 number[0]:5
 number[1]:2
 number[2]:1
 number[3]:1314
 */

指针数组

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
28
29
30
31
32
33
34
35
36
37
#include "stdio.h"
int main()
{
    //指针数组
    //整数指针
    int number[4]={5,2,1,1314};
    int i=0,*num[4];
    for (i=0; i<=3; i++) {
        num[i]=&number[i];
    }
    for (i=0; i<=3; i++) {
        printf("number[%d]:%d\n",i,*num[i]);
    }
    printf(" \n");
    //用一个指向字符的指针数组来存储一个字符串列表
    printf("这就是我想要对你说的话：\n");
    char *zifu[]={"I love you!","I love python!","But i love you best!"};
    int j=0;
    for (j=0; j<3; j++) {
        printf("%s\n",zifu[j]);
    }
    
    
    
    
}
/*输出结果为：
 number[0]:5
 number[1]:2
 number[2]:1
 number[3]:1314
  
 这就是我想要对你说的话：
 I love you!
 I love python!
 But i love you best!
 */

指向指针的指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include "stdio.h"
int main()
{   //定义指向指针的指针时，一定要使用两个*号
    int num=20;
    int *zz=&num;
    int **zzz=&zz;
    //使用三种方法分别打印出变量num的值
    printf("num的值是：%d\n",num);
    printf("num的值是：%d\n",*zz);
    printf("num的值是：%d\n",**zzz);
    
    
}
/*输出结果为：
 num的值是：20
 num的值是：20
 num的值是：20
 */

传递指针给函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include "stdio.h"
#include "time.h"
void sj(unsigned long *zz);
int main()
{   //通过传递指针给函数，可以直接修改原参数（实参），而不是引用实参到形参。
    unsigned long shijian;
    sj(&shijian);
    printf("当前时间参数是：%ld\n",shijian);
}

void sj(unsigned long *zz)
{
    *zz=time(NULL);
    return ;
}
/*输出结果为：
 当前时间参数是：1575623559
 */

能接受指针作为参数的函数，也能接受数组作为参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include "stdio.h"
double get(int  *zz);
int main()
{   //通过传递指针给函数，可以直接修改原参数（实参），而不是引用实参到形参。
    int number[6]={1,2,3,4,5,6};
    double jieguo;
    jieguo=get(number);
    printf("它们的平均数是：%lf\n",jieguo);
}

double get(int *zz)
{
    int i=0;int sum=0;
    for (i=0; i<=5; i++) {
        sum=sum+zz[i];
    }
    return (double)sum/6;
    
}
/*输出结果为：
 它们的平均数是：3.500000
 */

从函数返回指针

1
2


发表于 更新于 分类于

函数指针

怎么使用函数指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<stdio.h>
#include<string.h>
#include "stdlib.h"
#include "time.h"
int suiji(){
    return rand();
}
int main()
{
    int (*p)()=&suiji;//声明函数指针
    int a=p();
    printf("%d\n",a);
}
/*
 16807
 */

回调函数

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
28
29
30
31
32
#include<stdio.h>
#include<string.h>
#include "stdlib.h"
#include "time.h"
void huidiao(int x,void (*print)(void)){
    for (int i=0; i<x; i++) {
        print();
    }
    
    
}
void print(){
    printf("*\n");
}
int main(){
    int a=10;
    huidiao(a, print);
}
/*
 
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 
 */

发表于 分类于

实验七 函数

基础

3.编写一个函数，接收两点的坐标，计算并返回这两点之间的距离。建议函数原型:double Distance(int x1 ， int y1 ， int x2 ， int y2) ;

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
//实验七 基础3
#include <stdio.h>
#include "math.h"
/*编写一个函数，接收两点的坐标，计算并返回这两点之间的距离。建议函数原型:
double Distance(int x1 ， int y1 ， int x2 ， int y2) */
double Distance(int x1,int y1,int x2,int y2);//函数声明
double Distance(int x1,int y1,int x2,int y2){//函数定义，包含三个形参
    int x_chazhi;                           //函数主体
    int y_chazhi;
    x_chazhi=(x1-x2);
    y_chazhi=(y1-y2);
    return sqrt(x_chazhi*x_chazhi+y_chazhi*y_chazhi);//返回两点之间的距离
}
int main()                                  //main()函数
{
    double jieguo;int x1,y1,x2,y2;
    x1=0;y1=0;x2=1;y2=1;
    jieguo=Distance(x1, y1, x2, y2);            //实现两次函数调用，将返回值存储在变量jieguo中，并输出结果
    printf("(%d,%d)到(%d,%d)的距离是：%lf\n",x1,y1,x2,y2,jieguo);
    x1=2;y1=3;x2=5;y2=4;
    jieguo=Distance(x1, y1, x2, y2);
    printf("(%d,%d)到(%d,%d)的距离是：%lf\n",x1,y1,x2,y2,jieguo);
}
/*输出结果为：
 (0,0)到(1,1)的距离是：1.414214
 (2,3)到(5,4)的距离是：3.162278
 */

进阶

7.写一个函数:求一个实数的整数次幂。

在主函数main中输入一个实数 x 和正整数m，调用该函数求这个实数 x 的m次幂。要求该函数能够正确地计算负幂。同时，该函数实现 0 的任何次幂为 0 ，并 且任何数值的 0 次幂为 1 。使用循环方法实现。建议函数原型:double Power(double dblRealNumber ， int intPositiveNumber) ;

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
//实验七 进阶7
#include "hanshu.h"//"stdio.h"在hanshu.h中
#include "stdlib.h"
double Power(double dblRealNumber,int intPositiveNumber);//函数声明
double Power(double dblRealNumber,int intPositiveNumber){//函数定义
    double jieguo=0,jieguo1=0;int i=1;                  //函数体
    if (dblRealNumber==0) {                             //实现0的任何次幂为0
        jieguo=0;
    }
    else if ((dblRealNumber!=0)&&(intPositiveNumber==0)){//实现非零实数x的0次幂为1
        jieguo=1;
    }
    else if (intPositiveNumber>0){                      //使用循环，计算出n>0时n次幂的结果
        jieguo=1;
        while (i<=intPositiveNumber) {
            jieguo=jieguo*dblRealNumber;
            i++;
        }
    }
    else{
        jieguo1=1;
        while (i<=abs(intPositiveNumber)) {             //使用循环，计算出n<0时n次幂的结果
            jieguo1=jieguo1*dblRealNumber;
            i++;
        }
        jieguo=1/jieguo1;
    }
        return jieguo;
}
int main()                                              //调用函数，对函数的各个功能进行检测
{   double jieguo,x;int n;
    x=2;n=2;
    jieguo=Power(x,n);
    printf("%.2lf的%d次方结果是：%.2lf\n",x,n,jieguo);
    x=2;n=-2;
    jieguo=Power(x,n);
    printf("%.2lf的%d次方结果是：%.2lf\n",x,n,jieguo);
    x=-2;n=-2;
    jieguo=Power(x,n);
    printf("%.2lf的%d次方结果是：%.2lf\n",x,n,jieguo);
    x=0;n=-2;
    jieguo=Power(x,n);
    printf("%.2lf的%d次方结果是：%.2lf\n",x,n,jieguo);
    x=0;n=0;
    jieguo=Power(x,n);
    printf("%.2lf的%d次方结果是：%.2lf\n",x,n,jieguo);
    x=-2;n=0;
    jieguo=Power(x,n);
    printf("%.2lf的%d次方结果是：%.2lf\n",x,n,jieguo);
}
/*输出结果为：
 2.00的2次方结果是：4.00
 2.00的-2次方结果是：0.25
 -2.00的-2次方结果是：0.25
 0.00的-2次方结果是：0.00
 0.00的0次方结果是：0.00
 -2.00的0次方结果是：1.00
 */

发表于 分类于 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#字符串相加
a="Hello world! "
b="I love you !"
print(a+b)
'''输出结果为：Hello world! I love you !'''
#字符串乘法
print(a*3)
#判断特定字符是否在字符串中
print('o' in a)
print('R' in a)
#字符串索引
print(a[0])#输出H
#使用索引输出部分字符串
print(a[0:5])
#输出H,需要注意的是索引冒号后面的表示到这个数之前位置，也就是只输出到它之前的那个数字

发表于 更新于 分类于

方法一

由于函数传递时实参无法改变，所以使用了全局变量来完成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
int a,b;
void jiaoHUAN(int a,int b){
    int c;
    c=a;
    a=b;
    b=c;
    printf("a:%d,b:%d\n",a,b);
}



int main(){
    a=3;
    b=2;
    jiaoHUAN(a, b);

}
/*输出结果为：
a:2,b:3
*/

方法二

使用数组，从而避免使用了全局变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
void jiaoHUAN(int a[2]){
    
    int zhongjian;
    zhongjian=a[0];
    a[0]=a[1];
    a[1]=zhongjian;
    printf("a:%d,b:%d\n",a[0],a[1]);
    
    
}



int main(){
    int b[2]={3,2};
    jiaoHUAN(b);
    
}
/*输出结果为：
 a:2,b:3
 */

发表于 分类于

C语言实例之随机数生成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/*rand函数用来产生随机数，但是rand（）的内部是用线性同余法实现的，是伪随机数。在调用rand函数之前，可以使用srand函数设置随机数种子，如果没有设置随机数种子，rand函数在调用时，自动设计随机种子为1.随机种子相同，每次产生的随机数都是相同的，这就是为什么叫做伪随机数。*/
#include "stdio.h"
#include "stdlib.h"//rand函数的头文件为：stdlib.h
#include "time.h"//strand()函数需要的参数为seed，通常利用time(0)的返回值作为seed。time.h是time的头文件
int main(){
    srand((int)time(0));
    int SJ[5];int i=0;
    for (i=0; i<=4; i++) {
        SJ[i]=rand()&101; //获取0到100的随机数，包括100
    }
    for (i=0; i<=4; i++) {
        printf("%d\n",SJ[i]);
/*输出结果为：
 100
 33
 33
 5
 32
 这样就完成了随机数的输出
 */
    }