一些C语言笔记

*****************************************************************************************
    核心
*****************************************************************************************





/*    内部变量、外部变量    */


内部变量：定义在函数内部的函数参数和变量（作用域从定义处开始到该函数结束，生命周期从定义处开始到该函数结束）

外部变量：定义在函数外部的变量（作用域从定义处开始到整个程序结束，生命周期从定义处开始到整个程序结束）；如果要在外部变量的定义之前使用该变量，或者外部变量的定义与变量的使用不在同一个源文件中，则必须在相应的变量声明中强制的使用关键字extern（关键字extern只能用于声明变量或函数，而无法定义变量或函数）；外部变量的初始化只能出现在其定义中


//外部变量的声明

#include <stdio.h>

int main(void)
{
    extern int i;
    printf("%d/n", i);
    return 0;
}

int i =7777;    //外部变量的初始化只能出现在其定义中

//运行结果为7777





/*    动态变量、静态变量    */


动态变量：普通的变量

静态变量：用关键字static声明

    内部静态变量：与内部动态变量类似，唯一的不同点是：不管其所在函数是否被调用，内部静态变量一直存在，而不像自动变量那样，随着所在函数的调用和退出而存在和消失（作用域从定义处到该函数结束，生命周期从定义处到整个程序结束）

    外部静态变量（常用）：外部变量用static声明后，只对所在的文件可见，而其他文件都无法访问（作用域从定义处到该文件结束，生命周期从定义处到整个程序结束）





/*    定义一个指向常量的常量指针    */


const char *const msg = "my name is zlj!"





/*    指针    */


指向函数的指针：int(*pmax)(int, int);

函数返回值是指针：int *max(int, int);

指向数组的指针：int zlj[2][3];
        int(*pzlj)[3];
        pzlj = zlj;

指针数组：int *zlj[3];

强制类型转换：
int zlj[][];
int *pzlj = NULL;
pzlj = (int *)zlj;

(float)a    //把a转换为实型





/*    多为数组理解    */


int ia[3][4]
//array of size 3, each element is an array of ints of size 4
//相当于一维数组的元素又是数组





*****************************************************************************************
    概念相关
*****************************************************************************************





/*    基本输入输出    */


#include <stdio.h>
void main(int)
{
    char c;
    printf("please enter a string : /n");
    while((c = getchar()) != EOF)            //当输入完字符串按回车时，c编译器自动添加结束标志“EOF”
        putchar(c);
}





#include<stdio.h>
void main(int)
{
    char c[] = "zlj is my name!";            //c编译器自动将字符串输入数组c，并在结尾处加“/0”
    printf("%s/n", c);                //用printf输出字符串要用数组名c，遇到“/0”时停止打印

    char *ch = "zlj is my name!";
    printf("%s/n", ch);                //同理

    char z;
    printf("please enter a char : /n");
    scanf("%c", &z);                //scanf的用法，注意“&”

    char zlj[20];
    printf("please enter a string : /n");
    scanf("%s", zlj);                //scanf输入字符串时，遇到“ ”停止输入
    printf("%s", zlj);
}





/*    全局变量与局部变量    */


#include<stdio.h>
int max(int x,int y)
{
    int z;
    z=x>y?x:y;
    return(z);
}

void main(int)
{
    extern A,B;
    printf("%d/n",max(A,B));
}
int A=13,B=-8;

/*    在本程序文件的最后1行定义了外部变量A，B，但由于外部变量定义的位置在函数main之后，因此本来在main函数中不能引用外部变量A，B。现在我们在main函数中用extern对A和B进行“外部变量声明”，就可以从“声明”处起，合法地使用该外部变量A和B。    */





/*    动态存储方式与静态存储方式    */


//静态存储方式：是指在程序运行期间分配固定的存储空间的方式。(全局变量以静态方式存储)
//动态存储方式：是在程序运行期间根据需要进行动态的分配存储空间的方式。

//在c语言中，每个变量和函数有两个属性：数据类型和数据的存储类别。





*****************************************************************************************
    常用表达
*****************************************************************************************





/*    if-else 语句    */


if( condition )
    {
    statement 1;
    }
else
    {
    statement 2;
    }





/*    switch 语句    */


    swtich( 被计算的表达式 )
    {
    case 常量表达式 :
        statement 1;
        break;

    ……

    case 常量表达式 :
        statement n;
        break;
    default :
        statement n+1;
        break;
    }





/*    for 语句    */


    for( init_statement; condition; expression)
    {
    statement;
    }





/*    while 语句    */


    while( condition )
    {
    statement;
    }





/*    do-while 语句    */


    do
    {
    statement;
    }
    while( condition );





/*    break和continue    */


break：直接跳出整个循环
continue：跳出本次循环，继续下一次循环





/*    (a ? b : c)表达式    */


#include <stdio.h>
void main(int)
{
    int i = 1, j = 2;
    printf("the bigger one is : /n%d/n", ((i > j) ? i :j));
}





*****************************************************************************************
    指针、数组、函数相关
*****************************************************************************************





/*    一维数组与指针关系    */


#include <stdio.h>
void main(int)
{
    int zlj[5], *ptr = NULL;

//zlj[5]定义一个有5个元素的数组，数组名zlj表示数组第一个元素的地址，(zlj + 0)、(zlj + 1)分别表示数组第一个、第二个元素的地址，zlj[0]、zlj[1]分别表示数组第一个、第二个元素的值

    for(int i = 0; i < 5; ++i)
    {
        zlj[i] = (i + 1);
    }
    ptr = zlj;
    for(int j = 0; j < 5; ++j)
    {
        printf("%d/n", *ptr);
        ++ptr;                    //“++ptr”可以，但“++zlj”不可以
    }
}





/*    二维数组与指针关系    */


#include <stdio.h>
void main(int)
{
    int zlj[2][3] = {{1, 2, 3}, {4, 5, 6}};
    int (*pzlj)[3] = zlj;                //定义一个指向数组的指针，其实是把二维数组当做一维看
    printf("%x/t%x/t%x/n", zlj, (zlj + 0), zlj[0]);    //都输出第一行第一个元素的地址
    printf("%d/t%d/t%d/n", *(*pzlj + 1), *(*(pzlj + 0) + 1), *(zlj[0] + 1));
                            //都输出第一行第二个元素的值
}

/*    可以把二维数组zlj分解成两个一维数组来处理，zlj[0]、zlj[1]分别表示第一行、第二行的首地址，从指针的角度看，zlj、(zlj + 1)同样分别表示第一行、第二行的首地址，(zlj[1] + 1)或(*(zlj + 1) + 1)都表示第二行第二个元素的地址，*(zlj[1] + 1)或*(*(zlj + 1) + 1)都表示第二行第二个元素的值    */





/*    数组指针    */


类型说明符 (*指针变量名)[长度]

int (*p)[3];                        //p是指针，指向数组





/*    指针数组    */


类型说明符 *数组名[数组长度]

int *p[3];                        //p[3]是数组，里面放指针





/*    函数指针（指向函数的指针）    */


//在Ｃ语言中，一个函数总是占用一段连续的内存区，而函数名就是该函数所占内存区的首地址


类型说明符 (*指针变量名)(形参表);            //函数指针变量定义的一般形式

#include <stdio.h>
int max(int a, int b)
{
    if(a > b)
        return a;
    else
        return b;
}

void main(int)
{
    int max(int a, int b);
    int(*pmax)(int, int);                //定义一个函数指针
    int x, y, z;
    pmax = max;                    //函数名就是函数的首地址
    printf("input two numbers:/n");
    scanf("%d%d", &x, &y);
    z = (*pmax)(x, y);                //可用z = pmax(x, y)代替
    printf("maxmum = %d/n", z);
}





/*    指针型函数（函数返回值是指针）    */


类型说明符 *函数名(形参表)
{
    ……；
}                            //指针型函数的一般形





/*    数组作为函数的形参    */


f(int arr[],int n);                    //两个参数分别表示数组名和数组个数
                            //也可改为f(int *arr, int n)
{
    ……;
    ……;
}

void main(int)
{
    int array[10];
    f(array,10);                    //调用函数
}





*****************************************************************************************
    结构体（struct stu与int等同）
*****************************************************************************************





/*    定义一个结构    */


struct 结构名
{
    成员表列
};                            //注意最后的分号

struct stu
{
    int num;
    char name[20];
    char sex;
    float score;
};                            //定义一个名为stu的结构体，最后加分号





/*    结构变量说明    */


struct stu
{
    ……
};
struct stu boy1,boy2;                    //第一种说明方法


struct stu
{
    ……
}boy1,boy2;                        //第二种说明方法


struct
{
    ……
}boy1,boy2;                        //第三种说明方法





/*    结构变量的表示方法    */


结构变量名.成员名

boy1.num                        //即第一个人的学号
boy2.sex                        //即第二个人的性别





/*    结构变量的赋值与初始化    */


boy1.num=102;
boy1.name="Zhang ping";                    //赋值

struct stu boy1={102,"Zhang ping",'M',78.5};        //初始化





/*    结构数组的定义    */


struct stu
{
    int num;
    char *name;
    char sex;
    float score;
}boy[5];

//定义了一个结构数组boy，共有5个元素，boy[0]～boy[4]。每个数组元素都具有struct stu的结构形式





/*    指向结构变量的指针    */


struct 结构名 *结构指针变量名

struct stu *pstu = &boy1;                //pstu是指针，指向结构变量boy1


(*结构指针变量).成员名

(*pstu).num                        //结构成员访问方法一，等同于boy1.num


结构指针变量->成员名

pstu->num                        //结构成员访问方法二,等同于boy1.num





/*    动态存储分配    */


(类型说明符*)malloc(size)
//在内存的动态存储区中分配一块长度为"size"字节的连续区域。函数的返回值为该区域的首地址


(类型说明符*)calloc(n,size)
//在内存动态存储区中分配n块长度为“size”字节的连续区域。函数的返回值为该区域的首地址


free(void*ptr)
//释放ptr所指向的一块内存空间，ptr是一个任意类型的指针变量，它指向被释放区域的首地址。被释放区应是由malloc或calloc函数所分配的区域


void main(int)
{
    struct stu
    {
        int num;
        char *name;
        char sex;
        float score;
    } *ps;
    ps=(struct stu*)malloc(sizeof(struct stu));    //动态存储分配
    ps->num=102;
    ps->name="Zhang ping";
    ps->sex='M';
    ps->score=62.5;
    printf("Number=%d/nName=%s/n",ps->num,ps->name);
    printf("Sex=%c/nScore=%f/n",ps->sex,ps->score);
    free(ps);                    //释放
}





/*    链表    */


#include <stdio.h>
#include <stdlib.h>
struct peo
{
    char *name;
    int age;
    struct peo *next_p;
};

struct peo *creat(int n)
{
    struct peo *t = (struct peo*)malloc(sizeof(struct peo)), *first;
    first = t;
    for(int i = 0; i < n; ++i)
    {
        t->next_p = (struct peo*)malloc(sizeof(struct peo));
        t = t->next_p;
        t->next_p = NULL;
    }
    return (first);
}





/*    枚举类型    */


enum 枚举名{ 枚举值表 }

enum weekday{ sun,mou,tue,wed,thu,fri,sat };        //定义枚举类型
enum weekday a,b,c;                    //说明枚举类型
a=sun;
b=mon;
c=tue;                            //枚举类型赋值





/*    类型定义符    */


typedef int INTEGER;                    //用INTEGER代替int
INTEGER a,b;                        //相当于int a,b





*****************************************************************************************
    文件
*****************************************************************************************