1. 首页
  2. 文章中心
  3. C语言

C语言复习笔记

72 阅读 0 评论
我是靠谱客的博主 可靠鸭子，最近开发中收集的这篇文章主要介绍C语言复习笔记，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

参数地址空间

#include <stdio.h>
#include <stdlib.h>

//1.形式参数：作用域仅限于该函数
//2.形式参数也是一个变量，局部变量，有自己的内存空间
    /* a.空间的生存期，出生和死亡
    何时申请了该空间
    当函数被调用的时候才申请了内存空间，才有了这个变量
    同时这个空间内的数据被赋值成实际参数的值，函数调用把实际参数的值拷贝一份给形式参数
    
    何时释放了该空间
        函数执行结束以后，该空间由内存管理单元自动回收“释放”
    */

void test ()
{
    //printf ("jinshu = %dn",jinshu);
}

void buyRice2(int a)   //a 是一个局部变量，同时也是一个 1.形式参数，作用域仅限于该函数
{
    printf ("去买%d斤米。n",a);   //如果错误提示中包含 243  254 说明你写了中文符号
    a++;
    printf ("jinshu = %dn",a);
    printf ("buy中a的地址是%pn",&a);
}


int main ()
{
    int a = 30; //30 我们称之为形式参数
   
    buyRice2(a);    //如果调用的函数带有参数，必须传参！！！
                    //调用的时候，传递的参数叫做实际参数，对格式没有要求，对数据类型严格要求
    printf ("main: a = %dn",a);    //30
    printf ("main:a 的地址是%pn",&a);
    system ("pause");
    return 0;
}

sizeof与strlen的区别

#include <stdio.h>
#include <stdlib.h>

//计算字符串中字符的个数
//不能用sizeof来计算字符串中有效字符的个数！！！！！应该要用strlen，他在计算字符串大小的时候，遇到''后，就结束计数！
/*
问题：
网络通信，获取的消息有乱码
协议，两端不匹配
*/
int main()
{
    int a[] = {1,2,3};
    printf("数组中元素的个数：%dn",sizeof(a)/sizeof(a[0]));
    
    char array[] = "hello";
    printf("字符串中元素的个数：%dn",sizeof(array)/sizeof(char));
    
    char array2[] = "hello";
    printf("求字符串中元素的个数用strlen，%dn",strlen(array2));
    system("pause");
    return 0;
}

typedef关键字

#include <stdio.h>
#include <stdlib.h>

/*
typedef
typedef为c语言的关键字
作用是为一种数据类型定义一个新名字。
这里的数据类型包括内部数据类型（int char等）和自定义的数据类型（struct等）

和struct来匹配为了代码编写简洁
和普通类型匹配，通过名字来获取一些信息
*/
//在单片机开发，寄存器为8位 16位 32位

typedef unsigned char u_int8;   //(0,255)
typedef unsigned short int u_int16;
typedef unsigned int u_int32;

typedef struct student
{
    int score;
    char *name;
    void(*p)(struct student stu);
}STU,*PSTU;

typedef struct Node
{
    int data;
    struct Node* next;
}NODE,*PNODE;


int main()
{
    u_int8 data = 10;
    unsigned short int data2 = 20;
    u_int16 data3 = 30;
    u_int32 data4 = 40;

    STU stu1;
    stu1.score = 100;
    printf("score=%dn",stu1.score);

    PSTU pstu;
    pstu = (PSTU)malloc(sizeof(STU));
    pstu->score = 99;
    printf("score2=%dn",pstu->score);

    struct student *pstu3;
    pstu = (struct student *)malloc(sizeof(struct student));
    pstu->score = 98;
    printf("score3=%dn",pstu->score);

    printf("%d,%d,%d,%d",data,data2,data3,data4);


    system("pause");
    return 0;
}

for循环

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int score;
    int i;  //循环的初始条件
            //while（1）;  死循环
            //for (;;);         死循环
            //第二种循环  for循环
            //初始条件   当不满足此条件，不执行
            // i++  条件发生改变
    for (i = 0; i < 10; i ++){  //强调分号，分号不能掉，记住格式 for(i = 0; i < 10; i ++)
        //i = i + 1;  //条件发生改变

        //提示输入成绩
        printf ("请输入第%d次成绩：n",i+1);    //不改变原始次数

        //获取用户输入
        scanf ("%d",&score);

        //判断
        if (90<= score){
            printf ("成绩优秀n");
        }
        else if (70 <= score && score < 90){
            printf ("成绩良好n");
        }
        else if (60 <= score && score < 70){
            printf ("成绩及格n");
        }
        else if (40 <= score && score < 60){
            printf ("成绩不及格n");
        }
        else{
            printf ("很差劲，退学吧n");
        }

    }
    return 0;
    system ("pause");
}

数组100的和

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i;
    int array[100]; //定义了能放置100个数据的数组
    int sum=0;
    
    for(i=1;i<=100;i++){
        array[i-1]=i; 
        }   //赋值，获取1到100变量的数值
    
    for(i=0;i<100;i++){
        sum+=array[i];
    }
    
    printf("1到100的和是：%dn",sum);
    system("pause");
    return 0;
}

函数数组

#include <stdio.h>
#include <stdlib.h>


            //第一个参数是数组的首地址，第二个参数是数组的个数
void arrayPrint(int datas[], int cnt)   //形式参数中，虽然写的是一个参数的样子，中括号[]中数组的大小是无效的！！！！！
{                               //这里不管中括号中写多少，都不能代表形参数组有多大1
                                //这里的中括号的作用仅仅用来表示，该参数是一个地址，在windows中用4个字节来表示地址，在Linux64位中用8个字节表示。
    int i;
    for(i=0;i<cnt; i++){
        printf("%d ",datas[i]);
    }
    putchar('n');  //putchar 输出一个字符   getchar获取一个字符的输入，当时用于过滤回车
}
void noparams()
{
    printf("xxxn");
}

void hasparams(int a, int b, char c)
{
  printf("a=%d,b=%d,c=%cn",a,b,c);
}

int main()
{
    int array[6] = {11,22,35,44,55};
    printf("数组的大小是:%dn",sizeof(array));
    printf("array数组元素的个数为%d个n",sizeof(array)/sizeof(array[0]));
    //noparams();
    //hasparams(1,2,'c');
    //hasparams(array[0],array[1],'a');
    //两种方式来传参
    arrayPrint(array, sizeof(array)/sizeof(array[0]));
    arrayPrint(&array[0], sizeof(array)/sizeof(array[0]));


    //1.数组和函数结合，数组名当作实际参数

    int a[3];   //一个整型数占用空间4个字节，3个占用空间12个字节
    char b[3];  //一个char型占用空间1个字节，3个占用3个字节

    printf("a数组的大小是：%dn",sizeof(a));
    printf("b数组的大小是：%dn",sizeof(b));
    printf("一个整数的空间是%dn",sizeof(int));
    printf("一个字符型数的空间是：%dn",sizeof(char));

    //两个数组有什么相同，不同
    //相同：数组元素个数为3
    //不同：1.数组类型不同。2.数组的类型大小不同

    //问：如何计算数组中元素的个数。 数组的总大小/一个类型的大小

    printf("a数组有%d个元素n",sizeof(a)/sizeof(a[0]));//sizeof(a)/sizeof(int);
    printf("b数组有%d个元素n",sizeof(b)/sizeof(b[0]));//sizeof(b)/sizeof(char);


    system("pause");
    return 0;
}

函数指针

#include <stdio.h>
#include <stdlib.h>

void printWelcome()
{
    printf("欢迎你哦n");
}

int add(int a,int b)
{
    return a+b;
}


int main()
{

    //1.如何定义一个函数指针！
    void (*p)();    //1.如何表示指针：* 2.如何知道是函数:() 3.函数指针是专用的，格式很强（参数类型，个数，返回值），就像数组指针一样。
    //2.如何给函数指针赋值
    p = printWelcome;   //函数就是地址，就像数组一样，数组名就是地址

    //3.如何通过函数指针调用函数
    p();    //直接通过指针名字＋()
    (*p)(); //取内容 (*指针名字)

    int (*padd)(int a,int b);
    padd = add;
    //调用函数
    //int ret = padd(1,2);
    int ret = (*padd)(1,2);

    printf("ret=%dn",ret);


    system("pause");
    return 0;
}

函数和数组的综合应用

#include <stdio.h>
#include <stdlib.h>


void initScores(int *datas,int size)
{
    int i;
     for(i=0;i<10;i++){
        //2.1 提示用户输入第多少个数
        printf("请输入第%d个学生的成绩:",i+1);
        //2.2 获取用户输入的scanf
        scanf("%d",datas);
        if(*datas>100 || *datas<0){
            printf("哪里有这种成绩n");
            printf("强制退出，该程序不给xx用n");
            system("pause");
            exit(-1);
        }
        datas++;
    }
}


void printScores(int *datas,int size)
{
    int i;
    for(i=0;i<size;i++){
        printf("第%d个学生的成绩是：%dn",i+1,*datas++);
    }
}
int getMax(int *datas,int size)
{
    int data1;
    int i;
    data1=*datas;
    for(i=0;i<10;i++){
        if(data1 < *datas){
        data1 = *datas;
        }
        datas++;
    }
    return data1;
}

int getMin(int *datas,int size)
{
    int data2;
    int i;
    data2=*datas;
    for(i=0;i<10;i++){
        if(data2 > *datas){
        data2 = *datas;
        }
        datas++;
    }
    return data2;
}

float getAverage(int *datas,int size)
{
    int i;
    int total = 0;
    float average;
    for(i=0;i<10;i++){

       total+=*datas;
       //total = total + scores[i];
    }
    printf("总成绩为%dn",total);
        //5.2 算平均值
    average = (float)total/10;
    return average;
}

void printRet(int data1, int data2,float data3)
{
    printf("最高分%d  最低分%d  平均值%fn",data1,data2,data3);
}


int main()
{

    int scores[10];
    int len;
    int max;
    int min;
    float average;


    len = sizeof(scores)/sizeof(scores[0]);



    //1.初始化数组
    initScores(&scores[0],len); //函数调用中，传参就是一个赋值的过程，实际参数的值，给形式参数。
    //1.5 打印数组
    printScores(&scores[0],len);
    //2.找到最高分
    max = getMax(scores,len);
    //3.找到最低分
    min = getMin(scores,len);
    //4.算出平均分
    average = getAverage(scores,len);
    //5.输出结果
    printRet(max,min,average);

    system("pause");
    return 0;
}

数组指针

#include <stdio.h>
#include <stdlib.h>

//"指针数组"是多个指针
//"数组指针"是一个指针
int main()
{
    int a[3] ={1,2,3};
    
    int (*p) [3];   //数组的指针，强调的是类型，数组的个数，偏移值是偏移了整个数组的大小
    p = a;
    
    int *p2;
    p2 = a;
    
    printf("数组的地址是：%pn",a);
    printf("数组的地址是：%pn",&a[0]); 
    printf("p数组的地址是：%pn",p);    //0060FF18
                                        //0060FF0C  - = 12
                                        
                                        //0060FF10
                                        //0060FF0C  - = 4
    printf("p2数组的地址是：%pn",p2);
    
    printf("================区别来了================n");
    
    printf("p++的结果是：%pn",++p);
    printf("p2++的结果是：%pn",++p2);
    /*
    int *p; //此指针并非是数组指针，仅仅是一个普通的整型数的指针，刚好指向了数组的首元素地址a &a[0]
    p = a;
    p = &b;
    int i;
    for(i=0;i<3;i++){
        printf("%d n",*p++);
    }
    */
    
    system("pause");
    return 0;
}

为什么要用指针

#include <stdio.h>
#include <stdlib.h>

/*为什么要用指针*/

//1.能不能让a(10),强制保存在我要的地址 0060ff00  10   java 做不到

int main()
{   
    int a;  //a的地址肯定是系统随机分配的
    a = 10;
    
    int *p;
    p = &a;
    
    printf("a address is %pn",p);
    
    int *p2 = (int *)0x0060ff00;  //int a=10  ARM架构 裸机编程 ARM驱动
    *p2 = 10;
    printf("在内存的%p位置，存放值是%dn",p2,*p2);
    
    volatile int *p3 = (volatile int *)0x0060ff00;  //类型修饰符volatile是一个类型修饰符，作用是作为指令关键字，一般都是和const对应，确保本条指令不会被编译器的优化而忽略；const修饰的变量是不可被更新，去掉变量类型，const后面跟着什么，说明后面的这个就是不可变的
    system("pause");
    return 0;
}

结构体的定义和使用

#include <stdio.h>
#include <stdlib.h>
//struct 关键字
//1.结构体的定义和使用，！！！！！提醒：新手容易忘记在结构体}后面带上;
//2.如何访问结构体： 目标，内部的变量

struct student  //自定义的类型
{
    int scores;         //特性：分数
    char name[128];     //特性：名字
    int xueHao;         //特性：学号
    void (*pintroduce) (char *pname);   //行为：函数指针（自我介绍）
};

int main()
{
    //类型   变量名           初始值
    int      a  =               0;
    struct student stu1 = {98,"11",2019700002};
    printf("结构体：scores=%dn",stu1.scores);
    printf("结构体：name=%sn",stu1.name);
    printf("结构体：xuaHao=%dn",stu1.xueHao);

    struct student  aa = {99,"22",2019766666};
    printf("结构体：scores=%dn",aa.scores);
    printf("结构体：name=%sn",aa.name);
    printf("结构体：xuaHao=%dn",aa.xueHao);

    struct student test;
    test.scores = 99;
    strcpy(test.name,"33");
    test.xueHao=2019777777;
    printf("结构体：scores=%dn",test.scores);
    printf("结构体：name=%sn",test.name);
    printf("结构体：xuaHao=%dn",test.xueHao);

    system("pause");
    return 0;
}

结构体是不难的

#include <stdio.h>
#include <stdlib.h>

/*
结构体里面的那些东西，都是我们熟悉的东西，千万不要因为被一个结构体框起来以后就不知所措了。
旧的知识，新的用法！！！！！！！！
*/
void func(int data)
{
    printf("函数：data = %dn",data);
}


struct datas
{
    int a;
    char c;
    float f;
    double d;
    char str[128];
    void (*p)(int data);    //指针函数*p
};

/*
struct student
{
    char *name;
    char sex;
    int num;
    float scores;
    char *address;

    void (*peat)();
    void (*introduce)(char *name,char *address,char sex,int num);
};
*/
int main()
{
    int a = 10;
    printf("a = %dn",a);

    char c = 'M';
    printf("c = %cn",c);

    float f = 1.2;
    printf("f = %fn",f);

    double d = 3.4;
    printf("d = %lfn",d);

    //char *str = "陈立臣"; //初始化可以直接使用指针变量指向该字符串
    char *str;
    str = (char*)malloc(128);   //malloc用于开辟一个空间用来存放字符串
    memset(str,'',128);   //初始化
    str = "huyu";
    puts(str);

    void (*p)(int data) = func;
    p(10);

    puts("============================================");

    struct datas d1;
    d1.a = 100;
    d1.c = 'M';
    d1.f = 1.2;
    d1.d = 23.44;
    strcpy(d1.str,"陈立臣");	//strcpy函数是将一个字符串的全部内容（包括''）拷贝到另一个字符串里
    d1.p=func;

    printf("结构体：a=%dn",a);
    printf("结构体：c=%cn",c);
    printf("结构体：f=%fn",f);
    printf("结构体：d=%lfn",d);
    puts(d1.str);
    d1.p(10);	//10是参数

    system("pause");
    return 0;
}

结构体学生成绩例子

#include <stdio.h>
#include <stdlib.h>

struct Student
{
    int score;
    char *name;//4字节，linux中8字节
};
int main()
{
    int i;
    struct Student stu[3];
    //找最高分：人
    struct Student maxStu;
    struct Student minStu;

    for(i=0;i<sizeof(stu)/sizeof(stu[0]);i++){
        printf("请输入第%d个学生的名字：n",i+1);
        stu[i].name = (char *)malloc(128);
        scanf("%s",stu[i].name);
        printf("请输入第%d个学生的成绩：n",i+1);
        scanf("%d",&stu[i].score);
    }

    for(i=0;i<sizeof(stu)/sizeof(stu[0]);i++){
        printf("第%d个学生的名字和分数:",i+1);
        printf("%s：%dn",stu[i].name,stu[i].score);
    }


    maxStu = minStu =stu[0];    //初始化以便后面做判断
    for(i=0;i<sizeof(stu)/sizeof(stu[0]);i++){
        if(maxStu.score<stu[i].score){
            maxStu = stu[i];
        }
        if(minStu.score>stu[i].score){
            minStu = stu[i];
        }
    }

    printf("考最高分的是：%s：%dn",maxStu.name,maxStu.score);
    printf("考最低分的是：%s：%dn",minStu.name,minStu.score);

    system("pause");
    return 0;
}

结构体中常犯的错误

#include <stdio.h>
#include <stdlib.h>
//char : 1    int ：4    short : 2    unsigned int : 4    long : 8    unsigned long : 8    long long : 8     float : 4    double : 8    指针 : 8
struct Datas
{
    char *p;    //注意内存空间，容易犯错,占8字节
    
};

struct Test
{
    char p[128];
};

int main()
{
    struct Datas d;

    d.p = (char*)malloc(128);   //开辟一个空间存放，堆
    memset(d.p,'',128);   //初始化
    strcpy(d.p,"感觉自己萌萌哒");  //在linux 中段错误
    printf("%sn",d.p);
    printf("%dn",sizeof(struct Datas));
    system("pause");
    return 0;
}

结构体指针

#include <stdio.h>
#include <stdlib.h>

//1.如果要用结构体指针，就不能用！！点运算符！！！访问结构体中的变量要用->
struct student
{
    int score;
    char name[128];
};
int main()
{
    struct student Test;
    Test.score = 100;
    strcpy(Test.name,"张三");
    printf("%s:%dn",Test.name,Test.score);
    
    struct student *p;  //野指针，要避免野指针的出现
    //p.score = 100;    //如果用结构体指针，就不能用点运算来访问结构体中的变量，要用->
    p = (struct student *)malloc(sizeof(struct student));
    p->score=98;
    strcpy(p->name,"李四");
    printf("%s:%dn",p->name,p->score);
    
    free(p);
    p = &Test;  //指针是存放地址的变量，之前18行是指向malloc的那块空间，现在指针变量存的是Test的地址
    
    printf("地址是：%pn",p++);
    printf("加加后的地址是：%pn",p);
    
    system("pause");
    return 0;
}

结构体指针玩学生成绩

#include <stdio.h>
#include <stdlib.h>

struct student
{
    int score;
    char *name;
};

int main()
{
    int i;
    int len =0;
    printf("请输入总人数：n");
    scanf("%d",&len);
    
     struct student *p = (struct student *)malloc(len*sizeof(struct student));
    for(i=0;i<len;i++){
        printf("请输入名字：n");
        p->name = (char *)malloc(sizeof(128));
        scanf("%s",p->name);
        printf("请输入成绩：n");
        scanf("%d",&(p->score));
        p++;
    }
    
    p = p - len;
    for(i=0;i<len;i++){
        printf("学生成绩为：%s：%dn",p->name,p->score);
        p++;
    }
    /*struct student test[5];           //两种写法都对
    struct student *p = test;
    for(i=0;i<sizeof(test)/sizeof(test[0]);i++){
        printf("请输入名字：n");
        p->name = (char *)malloc(sizeof(128));
        scanf("%s",p->name);
        printf("请输入成绩：n");
        scanf("%d",&(p->score));
        p++;
    }
    
    p = test;
    for(i=0;i<sizeof(test)/sizeof(test[0]);i++){
        printf("学生成绩为：%s：%dn",p->name,p->score);
        p++;
    }
    */
    
    system("pause");
    return 0;
}

结构体指针综合应用

#include <stdio.h>
#include <stdlib.h>

struct student
{
    int score;
    char *name;
};

struct student* initStuScores(int len)
{
    int i;
    struct student *p = (struct student *)malloc(len*sizeof(struct student));
    for(i=0;i<len;i++){
        printf("请输入名字：n");
        p->name = (char *)malloc(sizeof(128));
        scanf("%s",p->name);
        printf("请输入成绩：n");
        scanf("%d",&(p->score));
        p++;
    }
    p = p - len;
    return p;
}

void printfMes(struct student* p,int len)
{
    int i;
    for(i=0;i<len;i++){
        printf("学生成绩为：%s：%dn",p->name,p->score);
        p++;
    }
}

struct student* findMaxStu(struct student* p,int len)
{
    int i;
    struct student *max;
    max = p;
    for(i=0;i<len;i++){
        if(max->score < p->score) {
            max = p;
        } 
        p++;
    }
    return max;
}

struct student *findMinStu(struct student* p,int len)
{
    int i;
    struct student *min;
    min = p;
    for(i=0;i<len;i++){
        if(min->score > p->score) {
            min = p;
        } 
        p++;
    }
    return min;    
}

float getAverage(struct student* p,int len)
{
    int total = 0;
    int i;
    for(i=0;i<len;i++){
        total += p->score;
        p++;
    }
    return (float)total/len;
}

int findStudentForName(struct student *p,int len,char *name)
{
    int i;
    for(i=0;i<len;i++){
        if(strcmp(name,p->name)==0){
            return 1;
        }else{
        return 0;
        }
        p++;
    }
}
int main()
{
    int i;
    int len =0;
    printf("请输入总人数：n");
    scanf("%d",&len);
    
    struct student *max = NULL;
    struct student *min = NULL;
    struct student* pstu = initStuScores(len);
    printfMes(pstu,len);
    
    max = findMaxStu(pstu,len);
    min = findMinStu(pstu,len);
    printf("max:%s:%dnmin:%s:%dnaverage:%fn",max->name,max->score,min->name,min->score,getAverage(pstu,len));
    if(findStudentForName(pstu,len,"zhangsan")==-1){
        printf("没有此人n");
    }else{
        printf("恭喜你，找到了n");
    }
    
    system("pause");
    return 0;
}

面试宝典结构体

#include <stdio.h>
#include <stdlib.h>

//一、结构体成员的偏移量必须是成员大小的整数倍（0被认为是任何数的整数倍）
//二、结构体大小必须是所有成员大小（数组除外，结构体除外）的整数倍
//对齐方式确实很浪费空间。。。。可是按照计算机的访问规则，这种对齐方式提升了效率

struct s1{
    char ch1;   //1
    char ch2;   //1
    int i;  //4 遵循结构体法则第一条，偏移量必须是当前成员的大小整数倍，逻辑偏移2 实际按照对齐的规则，要偏移成4
};

struct s2{
    char ch1;   //1
    int i;  //4+3
    char ch2;   //1+3
};

struct s3{
    char ch;    //1
    int i;  //4+3
    char str[12];//20
};

struct s4{
    char ch1;   //1
    int i;  //4+3
    struct s{   //16
        char ch2;   //1
        int j;  //4+3
        double d;   //8     
    }stmp;
    float f;    //32
};

struct s5{
    char ch;
    int i;
    union{
        char ch1;
        int j;//取最大项4
    };  //12
};

#pragma pack(4) //指向4对齐，最大是8
struct s6{
    char ch;
    int i;
    float f;//4
    double d;   //20
};

#pragma pack(10)
struct s7{
    char ch;
    int i;
    float f;    //12
    double d;   //20
};

int main()
{
    printf("char%dn",sizeof(char));	//1
    printf("float%dn",sizeof(float));	//4
    printf("int%dn",sizeof(int));	//4
    printf("double%dn",sizeof(double));	//8
    
    printf("s1:%dn",sizeof(struct s1));	//8
    printf("s2:%dn",sizeof(struct s2));	//12
    printf("s3:%dn",sizeof(struct s3));	//20
    printf("s4:%dn",sizeof(struct s4));	//32
    printf("s5:%dn",sizeof(struct s5));	//12
    printf("s6:%dn",sizeof(struct s6));	//20
    printf("s7:%dn",sizeof(struct s7));	//20
    system("pause");
    return 0;
}

无类型指针，内存泄漏解决方法

#include <stdio.h>
#include <stdlib.h>
int main()
{
    //int a[3];
    /*
    int *a = (int *)malloc(3*sizeof(int));  //也是数组
    int i;
    for(i=0;i<3;i++){
        a[i] = i;
    }
    for(i=0;i<3;i++){
        printf(" %d ",a[i]);
    }
    */
    
    /*
    避免内存泄露
    
    1.程序刚跑起来很好，跑几个小时或者几天，程序崩溃
    whike(1){
        sleep(1);
        int *p = malloc(1024);  malloc申请的空间，程序不会主动释放，Linux的话，程序结束后，系统会回收这个空间
        如何避免：
        1.注意循环中有没有一直申请
        2.及时合理的释放    free(p); p=NULL;//不让p成为野指针
        
        int p;
        p = NULL;
        
        int a = 0;
        int sum = 0;
    }
    
    */
    
    int n;
    printf("请输入你整型数组的元素总个数n");
    scanf("%d",&n);
    printf("n = %dn",n);
    //int parray[n];  //4种方式，3种合法，这种教材说非法
    
    int *parray = (int *)malloc(n*sizeof(int)); //数组
    if(parray == NULL){
        printf("开辟空间失败！n");
    }
    
    int i;
    for(i=0;i<n;i++){
        printf("请输入第%d个学生的成绩：",(i+1));
        scanf("%d",&parray[i]);
    }
    
    for(i=0;i<n;i++){
        printf("第%d个学生的成绩是：%dn",(i+1),*parray++);
    }
    
    
    system("pause");
    return 0;
}

指针收官，如何定义

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int i;  //定义整型变量i；
    int *p; //定义p为指向整型数据的指针变量
    
    int array[5];   //定义整型数组a，他有5个元素
    
    int *p[4];  //定义指针数组p,它由4个指向整型数据的指针元素组成  指针数组
    
    int (*p)[4];  //p为指向包含4个元素的一维数组的指针变量   数组指针
    int f();    //f为返回整型函数值的函数
    
    int* p();  //p为返回一个指针的函数，该指针指向整型数据
    int (*p) (); //p为指向函数的指针，该函数返回一个整型值
    int **p;    //p是一个指针变量，它指向一个指向整型数据的指针变量     //二级指针
    void *p;    //p是一个指针变量，基类型为void(空类型），不指向具体的对象
    
    system("pause");
    return 0;
}

字符串的操作

#include <stdio.h>
#include <stdlib.h>
int main()
{
    char *str = "哞哞";
    puts(str);
    printf("%sn",str);
    
    //char pstr[128] = {''};  //1.申请空间 2.初始化，把每个元素都初始化为''
    char *pstr; //野指针，造成非法内存访问，会出现段错误  cmd窗口闪退
    pstr = (char*)malloc(128);  //1.申请了空间 2.一旦用了malloc，一定要注意内存泄漏问题。3.malloc可能会失败，要对返回值做判断
    if(pstr == NULL){
        printf("申请内存失败！");
        exit(-1);
    }
    memset(pstr,'',128);  //初始化，把每个元素都初始化为''
    //三个要素1.params 参数，初始化的对象 2.初始化成什么字符 3.多大
    
    printf("请输入字符串n");
    //scanf("%d",pstr);
    gets(pstr);
    puts(pstr);
    
    
    system("pause");
    return 0;
}

字符串api

#include <stdio.h>
#include <stdlib.h>
int main()
{
    //char* strcpy(char* dest, const char *src);
    char *strDest;
    strDest = (char *)malloc(128);
    memset(strDest,'',128);   //初始化，防止*strDest成为野指针
    
    char *strSrc = "胡宇 胡宇";
    
    strcpy(strDest,strSrc); //字符串复制函数
    puts(strDest);
    
    strcpy(strDest,"huyu");
    puts(strDest);
    
    memset(strDest,'',sizeof(strDest)/sizeof(strDest[0]));    //重置
    strncpy(strDest,"clc hs", 3);   //char* strncpy(char *destinin,char *sourse,int maxlen);    //可选择复制的元素个数
    puts(strDest);
    
    char test[128] = "追西西科技 ";
    strcat(test,strSrc);    //追加在一个字符串的后面
    puts(test);
    
    char *str1 = "123";
    char *str2 = "123";
    
    int ret = strcmp(str1,str2);    //字符串的比较，str1<str2 ret=-1，str1>str2 ret=1, str1=str2 ret=0
    printf("ret = %dn",ret);
    if(ret==0){
        printf("两个字符串一样！n");
    }
    
    if(!strcmp(str1,str2)){ //!非0
        printf("两个字符串一样！n");
    }
    
    
    system("pause");
    return 0;
}

字符串api2

#include <stdio.h>
#include <stdlib.h>
#include<string.h>
/*
    函数原型
char *strchr(const char *str, int c)
参数
str-- 要被检索的 C 字符串。
c-- 在 str 中要搜索的字符。
功能
在参数str所指向的字符串中搜索第一次出现字符c（一个无符号字符）的位置。
返回值
返回一个指向该字符串中第一次出现的字符的指针，如果字符串中不包含该字符则返回NULL空指针。 [2] 
头文件
#include <string.h>*/

/*
函数原型：
1
 char *strstr(char *str1, const char *str2);
语法：
1
* strstr(str1,str2)
str1: 被查找目标　string expression to search.
str2: 要查找对象　The string expression to find.
返回值：若str2是str1的子串，则返回str2在str1的首次出现的地址；如果str2不是str1的子串，则返回NULL。
*/
/*
strlwr()用于将字符串中的字符转换为小写，其原型为：
    char *strlwr(char *str);

【参数说明】str为要转换的字符串。

【返回值】返回转换后的小写字符串，其实就是将str返回。

strupr作用相反，用法一样
*/
int main()
{
    char *str = "chenlichen";
    char *p = NULL;
    /*
    p = strchr(str,'i');
    if(p == NULL){
        printf("没有找到n");
    }else{
        Printf("找到n");
    puts(p);
        
    }
    */
    /*
    char *substr = "li";
    
    p = strstr(str,substr);
    if(p == NULL){
        printf("没有找到n");
    }else{
        printf("找到n");
        printf("%sn",p);
        puts(p);
    }
    
    char str1[] = "Hello Word"; //windows环境下 要定义成数组的形态，否则崩溃，Linux环境下可以用指针的
    puts(strlwr(str1));
    puts(strupr(str1));
    */
    
    
    //strtok字符串的分割 char *strtok(char *strings,const char *tokseps);chen,li,chen;
    char str2[] = "chen1,li,chen2,hu,yu";
    
    int i = 1;
    char *psubs[10];
    p = strtok(str2,",");
    if(p != NULL){
        printf("第%d个字符串：%sn",i,p);
        psubs[i-1] = p;
        }
    while(1){
        
        p = strtok(NULL,",");
        
        if(p != NULL){
            printf("第%d个字符串：%s n",++i,p);
            psubs[i-1] = p;
        }else{
            printf("没有子串了n");
            break;
        }
    }
    int j;
    for(j=0;j<i;j++){
        puts(psubs[j]);
    }
    system("pause");
    return 0;
}

最后

以上就是可靠鸭子为你收集整理的C语言复习笔记的全部内容，希望文章能够帮你解决C语言复习笔记所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(48)

相关文章

鉴源论坛 · 观辙丨汽车CAN总线渗透测试01 0203
鉴源论坛 · 观辙丨汽车CAN总线渗透测试01 0203
基于web的SCADA、HMI、Dashboard组态软件真正的大师,永远都怀着一颗学徒的心！四、界面展示
基于web的SCADA、HMI、Dashboard组态软件真正的大师,永远都怀着一颗学徒的心！四、界面展示
计算机模拟触摸屏,西门子人机界面（触摸屏HMI）与虚拟仿真应用技术
计算机模拟触摸屏,西门子人机界面（触摸屏HMI）与虚拟仿真应用技术
HMI自动化测试在持续集成环境中的应用
HMI自动化测试在持续集成环境中的应用
C语言复习笔记
C语言复习笔记
微机原理 基本常用操作指令
微机原理 基本常用操作指令
C语言 指令
C语言 指令
微机原理学习笔记——位操作指令逻辑运算指令AND、OR、NOT、XOR、TEST移位指令SHL、SHR、SAL、SAR循环移位指令ROL、ROR、RCL、RCR
微机原理学习笔记——位操作指令逻辑运算指令AND、OR、NOT、XOR、TEST移位指令SHL、SHR、SAL、SAR循环移位指令ROL、ROR、RCL、RCR

评论列表共有 0 条评论

立即
投稿
返回
顶部