复习C语言：第一章

　　复习C语言中的5中基本类型，以及各个类型占用了多少个字节：

#include <stdio.h>
int main(void) {
    printf("int=%d\n", sizeof(short int));
    printf("int=%d\n", sizeof(int));
    printf("int=%d\n", sizeof(long int));
    printf("char=%d\n", sizeof(char));
    printf("float=%d\n", sizeof(float));
    printf("float=%d\n", sizeof(double));
    return ;
}

　　复习数组， 常量指针， 变量指针， 常量指针的指向地址是不能改变的， 但是变量指针的指向地址是可以改变的：

#include <stdio.h>
int main() {
    int i;
    //a为常量指针
    int a[] = {,,,};
    int len = sizeof(a)/sizeof(a[]);
    //循环数组，并获取数组中的值;
    for(i= ;i<len; i++) {
        printf("%d\n",a[i]);
    };
    for(i= ;i<len; i++) {
        printf("%d\n",*(a+i));
    };
    //定义一个指针， 指向数组， 此时的指针pa为变量指针
    int* pa;
    pa = a;
    for(i= ;i<len; i++) {
        printf("%d\n", pa[i]);
    }
    for(i= ;i<len; i++) {
        printf("%d\n", *(pa+i));
    }
    //让指针 pa++ ,输出数组的指针
    printf("%d\n", *(pa++));
    //让数组 a++ ,输出结果, 会报错， 因为a是常量指针， 无法改变的;
    //printf("%d\n", a++);
    return ;
}

　　通过指针修改数组， 和直接修改数组的方式：

#include <stdio.h>

int main() {
    int ar[] = {,,,};
    int* p;
    p = ar;
    //*p = 0; //*p指向p的第一个元素;
    p[] = ; //这个上一行的代码效果一模一样;
    //*(p+1) = 0; //这一行和上面一行效果也是一样的
    p[] = ;
    printf("%d\n",ar[]);
    printf("%d\n",ar[]);
    return ;
}

　　在调用函数的时候，可以传值：

#include <stdio.h>
void Exchg1(int x, int y)
{
    int tmp;
    tmp=x;
    x=y;
    y=tmp;
    printf("x=%d,y=%d\n",x,y);
}
int main()
{
    int a=,b=;
    Exchg1 (a,b) ;
    printf("a=%d,b=%d\n",a,b);
    return ;
}

　　也可以传指针， 指针的话就变成后面的回调函数了:

#include <stdio.h>
void Exchg2(int *px, int *py)
{
    int tmp=*px;
    *px=*py;
    *py=tmp;
    printf("*px=%d,*py=%d\n",*px,*py);
}
int main()
{
    int a=;
    int b=;
    Exchg2( &a,&b);
    printf("a=%d,b=%d\n", a, b);
    return ;
}

　　指针是c中的一大玩点，  但是指针终究是指针 ， 如果参数为一个数组， 指针是无法获取到指针对应的值的长度的， 所以要把数组给一个函数， 都要把数组的长度作为参数传递？这个有待考证

#include <stdio.h>

void run(int *p, int *p1) {
    printf("p 的长度是%d\n", (int)sizeof(*p));
}
int main() {
    int a[] = {,,,,,,,};
    run(a, b);
    printf("a 的长度是 : %d\n", (int)sizeof(a));
    return ;
}

//输出：
//p 的长度是 : 4
//a 的长度是 : 32

#include <stdio.h>
//float average( int*p 一样 ,int len) {
float average( int a[] ,int len) {
    float val;
    int sum = ;
    //printf("%d\n", a);
    for(int i=; a[i]!=; i++) {
        printf("%d\n", a[i]);
    };
    a[] = ;
    return  val;
}
int main() {
    int x[] = {,,,,,,,,,,};
    float av;
    //c语言中的指针不带有长度信息， 必须把长度作为参数;
    av = average(x, sizeof(x)/);
    printf("%d\n", x[]);
    return ;
}

　　定义数组的变量，即为这个数组的首地址， 把数组作为参数的时候， 被调用的函数中的参数为这个数字的引用：

#include <stdio.h>

void average( int a[] ) {
    a[] = ;
}
int main() {
    int x[] = {,,,,,,,,,,};
    average(x);
    //x的第一个值是 : 9
    printf("x的第一个值是 : %d", x[]);
    return ;
}

　　接受参数的时候， 可以定义一个数组作为形参数：

#include <stdio.h>

void average( int* p ) {
    p[] = ;
}
int main() {
    int x[] = {,,,,,,,,,,};
    average(x);
    //输出：x的第一个值是 : 9
    printf("x的第一个值是 : %d", x[]);
    return ;
}

　　一个字符或者数字只是一个变量， 把以上两种类型作为参数的时候， 实际上传递的只是一个原始值的复制品：

#include <stdio.h>

void test( int p ) {
    p = ;
}
int main() {
    int x = ;
    test(x);
    //输出：x的第一个值是 : 0
    printf("x的值是 : %d", x);
    return ;
}

　　也可以把字符或者数字作为一个指针，传递给函数， 函数定义的时候接收， 在调用的函数中修改指针， 对应的变量会发生改变：

#include <stdio.h>

void test( int* p ) {
    *p = ;
}
int main() {
    int x = ;
    test(&x);
    //输出：x的第一个值是 : 9
    printf("x的值是 : %d", x);
    return ;
}

　　搞笑的数组和指针：

#include <stdio.h>

int main() {
    int a[];
    int *p;
    int i;
    for(p = a; p<a+; p++){
        printf("p is %d \n", p);
    }
    return ;
}

　　循环输入学生的分数，冒泡排序以后重新输出分数, malloc(Byte)：

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

void sort( int *s , int len) {
    int i = , j = ;
    //冒泡排序
    for(i=; i<len; i++) {
        for(j=i; j<len; j++) {
            if( s+j>s+i ) {
                int temp = ;
                temp = *(s+i);
                *(s+i) = *(s+j);
                *(s+j) = temp;
            }
        }
    }
}
int main() {
    int *a , j , n;
    scanf("%d\n",&n);
    a = (int *)malloc();
    for(j=; j<n; j++) {
        scanf("%d",a+j);
    }
    printf("puts trings\n");
    sort(a, n);
    for(j=; j<n; j++) {
        printf("%d\n",*(a+j));
    }
    free(a);
    return ;
}

　　实现一个命令行的投票功能， 输入li或者zhang， 投的票数会自动增加 ：

#include <stdio.h>
#include <string.h>
struct per {
    char name[];
    int count;
}leader[] = {{"li",},{"zhang",}};

int main() {
    int i , j;
    int p;
    char name[];
    printf("enter 'li' or 'zhang' : \n");
    for(i = ; i<; i++) {
        scanf("%s\n", name);
        for(j = ; j<; j++) {
            if(strcmp(leader[j].name, name) == ) {
                leader[j].count = leader[j].count+;
            };
        }
    }
    for(i = ; i< ; i++) {
        printf("user %s, count is %d\n", leader[i].name, leader[i].count);
    }
    return ;
}

　　

　　字符串的复制需要strcpy， 原始类型的复制可以使用左值直接赋值：

#include <stdio.h>
#include <string.h>
struct st{
    char name[];
    int age;
}s2;
int main() {
    char c[] = "abcd";
    char b[];
    strcpy(b,c);
    printf("string is : %s\n",b);
    struct st s1 = {"nono",};
    s2.age = s1.age;
    printf("s2 age is : %d\n", s2.age);
    strcpy(s2.name, s1.name);
    printf("s2 name is : %s\n", s2.name);
    return ;
}

　　

　　利用结构体实现简易的用户查询系统，  包含用户的添加以及查询：

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

struct user{
    int id;
    char name[];
    char descript[];
}s[];//预置20个用户
int count = ;

void find() {
    printf("please to enter user id:\n");
    int id = , i;
    scanf("%d", &id);
    for(i= ;i <count; i++) {
        if(s[i].id == id) {
            printf("user id is %d\n user name is %s \nuser desciprtion %s\n", s[i].id, s[i].name, s[i].descript);
        }
    }
}

void all() {
    int i = ;
    for(i= ; i<count; i++) {
        printf("user name : %d\n", s[i].id );
        printf("user name : %s\n", s[i].name );
        printf("user desciprtion : %s\n", s[i].descript );
    }
}

void add() {
    char name[];
    char descript[];
    printf("input user name :\n");
    scanf("%s",name);
    printf("input user desciprtion:\n");
    scanf("%s",descript);
    user s1; //= { count , *name, *descript};
    s1.id = count;
    strcpy(s1.name, name);
    strcpy(s1.descript, descript);
    s[count] = s1;
    count++;
}

int main() {
    //用户的输入:
    char ipt[];
    //循环获取用户的输入
    printf("%d\n", (int)(sizeof(s)/sizeof(s[])));
    while() {
        printf("\n\n\n\n输入查询:\n ");
        printf("查询所有输入:all \n 增加用户输入:add\n 查询详细输入:find\n");
        //获取用的输入
        scanf("%s", ipt);
        printf("%s", ipt);
        //查看所有的用户
        if(strcmp(ipt, "all")==) {
            all();
        }
        //增加一个用户
        if(strcmp(ipt,"add")==) {
            add();
        }
        //根据用户ID， 返回查询用户消息
        if(strcmp(ipt,"find")==) {
            find();
        }

    }
    return ;
}

　　内存管理(MM)， 通过malloc申请内存，以及使用free返还内存：

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

int main() {
    char *p;
    p = (char *)malloc();
    int i;
    for(i=; i<; i++) {
        p[i] = i;
    }
    for(i=; i<; i++) {
        printf("address is %p;content is %c\n",&p[i],p[i]);
    }
    free(p);
    return ;
}

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

int main() {
    char *p;
    p = (char *)malloc();
    int i;
    for(i=; i<; i++) {
        p[i] = i;
    }
    for(i=; i<; i++) {
        printf("address is %p;content is %c\n",&p[i],p[i]);
    }
    free(p);
    return ;
}

　　买车的实现：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
struct car{
    char maker[];
    int deposit;
};
struct people{
    char name[];
    int deposit;
    car *c;
};
void buy(people *p) {
    car *c = (car *)malloc(sizeof(car));
    strcpy(c->maker, "bench");
    c->deposit = ;
    p->deposit -= c->deposit;
    p->c = c;;
}
void discard(people *p) {
    free(p->c);
    p->c = NULL;
}
int main() {
    people p = {"nono",,NULL};
    printf("people name is : %s\n", p.name);
    printf("people deposit is : %d\n", p.deposit);
    buy(&p);
    printf("after buy it , people deposit is : %d\n", p.deposit);
    printf("%s has a car, the car name is %s\n",p.name, p.c->maker);
    discard(&p);
    return ;
}

　　链表的使用， 链表和数组的区别以及各自不同的使用场景，有头节点和无头节点的区别和区别：

　　链表是动态生成的， 可控性比数组好非常多， 数组的长度是固定的，但是链表可以无限延长， 对于链表的操作也比较灵活， 可以往链表的中间插入数据， 但是数组的插入是非常繁琐的；

　　有头链表保障了链表起码有一个开始， 对于数据的操作更灵活， 无头链表必须保证，头部有一个数据， 否者无法做后续操作：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
/*
*网吧用户管理系统
*/

struct User {
    //用户名
    char name[];
    //用户密码
    char pass[];
    //用户金额
    int deposit;
    User* next;
};

//察看所有
void showAll(User *user) {
    User *curr = user;
    while(curr->next) {
        curr = curr->next;
        printf("user : %s\ndeposit:%d\n",curr->name,curr->deposit);
    }
}
//添加用户
void add(User *user) {
    //局部创建的变量， 在离开该函数的作用域后， 会被自动清空;
    char name[];
    char pass[];
    int deposit = ;
    printf("please enter user name :\n");
    scanf("%s",name);
    printf("please enter user pass :\n");
    scanf("%s",pass);
    printf("please enter user deposit :\n");
    scanf("%d",&deposit);
    //必须使用MM申请空间， 然后再往user下添加数据
    User *u = (User*)malloc(sizeof(User));
    u->deposit = deposit;
    strcpy(u->name, name);
    strcpy(u->pass, pass);
    u->next = NULL;
    //循环，直到，user没有下一个数据;
    while(user->next){
        user = user->next;
        printf("find next\n");
    };
    user->next = u;
    //printf("next is :%p\n",user->next);
}
void find(User *user) {
    char name[];
    printf("enter user name to find : \n");
    scanf("%s", name);
    User *curr = user;
    while(curr->next) {
        if( strcmp(curr->next->name, name) ==  ) {
            printf("user is %s\ndeposit is %d\n", curr->next->name, curr->next->deposit);
            return ;
        }
        curr = curr->next;
    }
}
//删除用户
void remove(User *user) {
    char name[];
    printf("enter user name to rmove : \n");
    //数组的话只要传name，因为name本来就是一个地址
    //字符和数字要加&因为，他们本身是数据，要根据地址改数据;
    scanf("%s", name);
    User* curr = user->next;
    while( curr->next ) {
        if( strcmp(curr->next->name, name) ==  ) {
            User *now = curr->next;
            curr->next = now->next;
            free(now);
            printf("removed\n");
            return ;
        }
        user = user->next;
    }
}

int main() {
    User user = {"","",,NULL};
    char  cmdline[];
    while() {
        //输出查看,添加,删除命令
        printf("查看所有:all\n添加用户:add\n删除用户:remove\n查找用户信息:find\n");
        scanf("%s",cmdline);
        printf("you are enter : %s\n", cmdline);
        //如果是察看
        if(strcmp("all",cmdline) == ) {
            showAll(&user);
        };
        //如果是添加
        if(strcmp("add",cmdline)==) {
            add(&user);
        }
        //如果是删除
        if(strcmp("remove",cmdline)==) {
            remove(&user);
        }
        //如果是删除
        if(strcmp("find",cmdline)==) {
            find(&user);
        }
    }
    return ;
}

　　引用相关, 定义一个引用的时候， 必须初始化， 但是定义指针不要强制初始化, 定义完毕引用以后，无法解绑，被强制绑定， 无法重新赋值 :

#include <stdio.h>

struct stu {
    char name[];
    int age;
};
int main() {
    //refference引用是强化版的指针
    int a = ;
    //定义一个引用的时候， 必须初始化， 但是定义指针不要强制初始化
    //定义完毕引用以后，无法解绑，被强制绑定， 无法重新赋值
    int&b = a;
    printf("b = %d, address : %p\n", b,&b);
    printf("a = %d, address : %p", a,&a);
    stu s = {"nono",};
    stu& s1 = s;
    printf("把s1的age改成100");
    s1.age = ;
    printf("s的age is %d\n", s.age);\
    return ;
}

　　引用可以作为返回值：

#include <stdio.h>
int b = ;
int& test() {
    //如果我把b定义在test函数内部， 会报错， 因为函数执行完毕以后， 内部的所有变量都会被销毁;
    int& a = b;
    return a;
}
int main() {
    int& a = test();
    printf("The a is %d\n", a);
    return ;
}

　　可以把引用作为返回值， 但是这种写法不太好阅读， 不方便阅读理解：

#include <stdio.h>
int number = ;
int& test() {
    return number;
}
int main() {
    test() = ;
    printf("%d\n", number);
    return ;
}

　　 厦门点燃未来网络科技有限公司， 是厦门最好的微信应用， 小程序， 微信网站， 公众号开发公司