C语言复习笔记

参数地址空间

#include 
#include 

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

void test ()
{
    //printf ("jinshu = %d\n",jinshu);
}

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


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

sizeof与strlen的区别

#include 
#include 

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

typedef关键字

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

和struct来匹配为了代码编写简洁
和普通类型匹配，通过名字来获取一些信息
*/ 

//在单片机开发，寄存器为8位 16位 32位
typedef

unsigned char ; u_int8//(0,255)   typedef
unsigned short int ; u_int16typedef
unsigned int ; u_int32typedef

struct student int
{
    ; scorechar
    * ;namevoid
    (*)p(structstudent ) stu;}
,STU*;PSTUtypedef

struct Node int
{
    ; datastruct
    Node *; next}
,NODE*;PNODEint


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=%d\n",.stu1)score;;

    PSTU pstu=
    pstu ( )PSTUmalloc(sizeof()STU);=
    pstu->score 99 ;printf
    ("score2=%d\n",)pstu->score;struct

    student * ;pstu3=
    pstu ( structstudent * )malloc(sizeof(structstudent ));=
    pstu->score 98 ;printf
    ("score3=%d\n",)pstu->score;printf

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


    ("pause");return
    0 ;}
#

for循环

include# 
includeint 
main ()int
{
    ; scoreint
    ; i//循环的初始条件  //while（1）;  死循环
            //for (;;);         死循环
            //第二种循环  for循环
            //初始条件   当不满足此条件，不执行
            // i++  条件发生改变
            for
    ( =i 0 ;< i 10 ;++ i )//强调分号，分号不能掉，记住格式 for(i = 0; i < 10; i ++){  //i = i + 1;  //条件发生改变
        //提示输入成绩

        printf
        ( "请输入第%d次成绩：\n",+i1);//不改变原始次数    //获取用户输入

        scanf
        ( "%d",&)score;//判断

        if
        ( 90<=) scoreprintf{
            ( "成绩优秀\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# 
includeint 

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

函数数组

include# 
include//第一个参数是数组的首地址，第二个参数是数组的个数 


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

hasparams (int, aint , bchar ) cprintf
{
  ("a=%d,b=%d,c=%c\n",,a,b)c;}
int

main ()int
{
    [ array6]= 11 {,22,35,44,55};printf
    ("数组的大小是:%d\n",sizeof()array);printf
    ("array数组元素的个数为%d个\n",sizeof()array/sizeof([array0]));//noparams();
    //hasparams(1,2,'c');
    //hasparams(array[0],array[1],'a');
    //两种方式来传参
    arrayPrint
    (,arraysizeof ()array/sizeof([array0]));arrayPrint
    (&[array0],sizeof ()array/sizeof([array0]));//1.数组和函数结合，数组名当作实际参数


    int

    [ a3];//一个整型数占用空间4个字节，3个占用空间12个字节   char
    [ b3];//一个char型占用空间1个字节，3个占用3个字节  printf

    ("a数组的大小是：%d\n",sizeof()a);printf
    ("b数组的大小是：%d\n",sizeof()b);printf
    ("一个整数的空间是%d\n",sizeof(int));printf
    ("一个字符型数的空间是：%d\n",sizeof(char));//两个数组有什么相同，不同

    //相同：数组元素个数为3
    //不同：1.数组类型不同。2.数组的类型大小不同
    //问：如何计算数组中元素的个数。 数组的总大小/一个类型的大小

    printf

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


    ("pause");return
    0 ;}
#

函数指针

include# 
includevoid 

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

add (int, aint) breturn
{
    + a;b}
int


main ()//1.如何定义一个函数指针！
{

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

    p
    ();//直接通过指针名字＋()    (
    *)p();//取内容 (*指针名字) int

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

    ("ret=%d\n",)ret;system


    ("pause");return
    0 ;}
#

函数和数组的综合应用

include# 
includevoid 


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


printScores (int* ,datasint) sizeint
{
    ; ifor
    (=i0;<i;size++i)printf{
        ("第%d个学生的成绩是：%d\n",+i1,*++datas);}
    }
int
getMax (int* ,datasint) sizeint
{
    ; data1int
    ; i=
    data1*;datasfor
    (=i0;<i10;++i)if{
        (<data1 * )datas={
        data1 * ;datas}
        ++
        datas;}
    return
    ; data1}
int

getMin (int* ,datasint) sizeint
{
    ; data2int
    ; i=
    data2*;datasfor
    (=i0;<i10;++i)if{
        (*data2 > )datas={
        data2 * ;datas}
        ++
        datas;}
    return
    ; data2}
float

getAverage (int* ,datasint) sizeint
{
    ; iint
    = total 0 ;float
    ; averagefor
    (=i0;<i10;++i)+={

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

printRet (int, data1int , data2float) data3printf
{
    ("最高分%d  最低分%d  平均值%f\n",,data1,data2)data3;}
int


main ()int
{

    [ scores10];int
    ; lenint
    ; maxint
    ; minfloat
    ; average=


    len sizeof ()scores/sizeof([scores0]);//1.初始化数组



    initScores
    (&[scores0],)len;//函数调用中，传参就是一个赋值的过程，实际参数的值，给形式参数。 //1.5 打印数组
    printScores
    (&[scores0],)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# 
include//"指针数组"是多个指针 

//"数组指针"是一个指针
int
main ()int
{
    [ a3]= 1{,2,3};int
    
    ( *)p[ 3];//数组的指针，强调的是类型，数组的个数，偏移值是偏移了整个数组的大小   =
    p ; aint
    
    * ;p2=
    p2 ; aprintf
    
    ("数组的地址是：%p\n",)a;printf
    ("数组的地址是：%p\n",&[a0]);printf 
    ("p数组的地址是：%p\n",)p;//0060FF18    //0060FF0C  - = 12
                                        //0060FF10
                                        
                                        //0060FF0C  - = 4
                                        printf
    ("p2数组的地址是：%p\n",)p2;printf
    
    ("================区别来了================\n");printf
    
    ("p++的结果是：%p\n",++)p;printf
    ("p2++的结果是：%p\n",++)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# 
include/*为什么要用指针*/ 

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

int

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

结构体的定义和使用

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

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

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

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

    student ; test.
    test=scores 99 ;strcpy
    (.test,name"33");.
    test=xueHao2019777777;printf
    ("结构体：scores=%d\n",.test)scores;printf
    ("结构体：name=%s\n",.test)name;printf
    ("结构体：xuaHao=%d\n",.test)xueHao;system

    ("pause");return
    0 ;}
#

结构体是不难的

include# 
include/*
结构体里面的那些东西，都是我们熟悉的东西，千万不要因为被一个结构体框起来以后就不知所措了。
旧的知识，新的用法！！！！！！！！
*/ 

void
func (int) dataprintf
{
    ("函数：data = %d\n",)data;}
struct


datas int
{
    ; achar
    ; cfloat
    ; fdouble
    ; dchar
    [ str128];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 = %d\n",)a;char

    = c 'M' ;printf
    ("c = %c\n",)c;float

    = f 1.2 ;printf
    ("f = %f\n",)f;double

    = d 3.4 ;printf
    ("d = %lf\n",)d;//char *str = "陈立臣"; //初始化可以直接使用指针变量指向该字符串

    char
    * ;str=
    str ( char*)malloc(128);//malloc用于开辟一个空间用来存放字符串   memset
    (,str','128);//初始化=   "huyu"
    str ; puts(
    );strvoid(

    * )(pint)= data; p func(
    10);puts(

    "============================================");structdatas

    ; . d1=
    d1100a ; .=
    d1'M'c ; .=
    d11.2f ; .=
    d123.44d ; strcpy(
    .,d1"陈立臣"str);//strcpy函数是将一个字符串的全部内容（包括'.'）拷贝到另一个字符串里=	;
    d1printfp(func"结构体：a=%d\n"

    ,);printfa("结构体：c=%c\n"
    ,);printfc("结构体：f=%f\n"
    ,);printff("结构体：d=%lf\n"
    ,);putsd(.
    );d1.strp(
    d110);//10是参数system(	"pause"

    );return0;
    } #include
#

结构体学生成绩例子

includestruct 
Studentint 

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

    0;i<sizeof(i)/sizeofstu([0]stu);++)printfi("请输入第%d个学生的名字：\n"{
        ,+1)i;[].
        stu=i(charname * )malloc (128);scanf("%s"
        ,[].stu)i;printfname("请输入第%d个学生的成绩：\n"
        ,+1)i;scanf("%d"
        ,&[].stu)i;}scorefor(
    =

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


    maxStu 0 minStu ]stu;//初始化以便后面做判断for(    =
    0;i<sizeof(i)/sizeofstu([0]stu);++)ifi(.{
        <[maxStu]score.stu)i=[score]{
            maxStu ; stu}iif(
        .
        []minStu.score>stu)i=[score]{
            minStu ; stu}i}printf
        (
    "考最高分的是：%s：%d\n"

    ,.,.maxStu)name;maxStuprintfscore("考最低分的是：%s：%d\n"
    ,.,.minStu)name;minStusystemscore("pause"

    );return0;
    } #include
#

结构体中常犯的错误

include//char : 1    int ：4    short : 2    unsigned int : 4    long : 8    unsigned long : 8    long long : 8     float : 4    double : 8    指针 : 8 
structDatas 
char
* ;
{
    //注意内存空间，容易犯错,占8字节 }p;    struct
    
Testchar

[ 128
{
    ] p;};int
main(

) structDatas;
{
    . = d(

    dcharp * )malloc(128);//开辟一个空间存放，堆memset(   .
    ,','d128p);//初始化strcpy(.   ,
    "感觉自己萌萌哒")d;p//在linux 中段错误printf("%s\n"  ,
    .);printfd(p"%d\n",
    sizeof(structDatas)); system("pause")
    ;return0;}
    # include#
include

结构体指针

structstudent 
int; 

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

结构体指针玩学生成绩

structstudent 
int; 

char *
{
    ; score}
    ; intnamemain
()

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

结构体指针综合应用

structstudent 
int; 

char *
{
    ; score}
    ; structnamestudent
*initStuScores

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

student *,int )int p;for len(
{
    = i0
    ;<i;++)iprintflen(i"学生成绩为：%s：%d\n",{
        ,);++p->name;p->score}}
        pstructstudent
    *
findMaxStu

( structstudent *,int )int p;struct lenstudent
{
    * i;
    = ; formax(
    max = p0
    ;<i;++)iiflen(i<){
        =;max->score } p->score++ {
            max ; p}
        return 
        p;}
    struct
    student max*
findMinStu

( struct student*,int )int p;struct lenstudent
{
    * i;
    = ; formin(
    min = p0
    ;<i;++)iiflen(i)={
        ;}min->score > p->score++ {
            min ; p}
        return 
        p;}
    float
    getAverage min(    
struct

student *,int )int p=0 len;
{
    int total ; for(
    = i0
    ;<i;++)i+=len;i++;{
        total } p->scorereturn
        p(float
    )
    / ;}inttotalfindStudentForNamelen(
struct

student *,int , charp*) lenint; forname(
{
    = i0
    ;<i;++)iiflen(istrcmp({
        ,)==0name)p->namereturn1;}{
            else return0
        ;}{
        ++ ;}
        }
        pintmain
    (
)
int ;int=
{
    0 i;
    printf len ("请输入总人数：\n")
    ;scanf("%d",
    &);structstudentlen*=
    
    NULL ; structmax student *=
    NULL ; structmin student *=
    initStuScores () pstu ; printfMes(len,)
    ;=pstufindMaxStulen(,
    
    max ) ;=pstufindMinStulen(,
    min ) ;printfpstu(len"max:%s:%d\nmin:%s:%d\naverage:%f\n",
    ,,,,max->namegetAveragemax->score(min->name,min->score));pstuiflen(findStudentForName(
    ,,"zhangsan")pstu==len-1)printf("没有此人\n"){
        ;}elseprintf(
    "恭喜你，找到了\n"){
        ;}system("pause"
    )
    
    ;return0;}
    # include#
include

面试宝典结构体

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

s1
char
;

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

//1 int{
    ; ch1//4+3   char
    ; i//1+3  }
    ; ch2struct   s3
char;

//1 int{
    ; ch//4+3    char
    [ i12  ]
    ; str//20};structs4
char;

//1 int{
    ; ch1//4+3   struct
    s i//16  char
    ; //1{   int
        ; ch2//4+3   double
        ; j//8       }
        ; dfloat   ;
    //32stmp}
    ; fstruct    s5
char;

int ;{
    union chchar
    ; iint
    ;{
        //取最大项4 ch1}
        ; j//12}
    ;#  pragma
pack(

4) //指向4对齐，最大是8structs6char ;
int ;{
    float ch;
    //4 idouble
    ; f//20}
    ; d#   pragma
pack(

10) structs7char;
int ;{
    float ch;
    //12 idouble
    ; f//20    }
    ; dint   main
()

printf ("char%d\n",
{
    sizeof(char));//1printf("float%d\n"	,
    sizeof(float));//4printf("int%d\n"	,
    sizeof(int));//4printf("double%d\n"	,
    sizeof(double));//8printf("s1:%d\n"	,
    
    sizeof(structs1)); //8printf("s2:%d\n"	,
    sizeof(structs2)); //12printf("s3:%d\n"	,
    sizeof(structs3)); //20printf("s4:%d\n"	,
    sizeof(structs4)); //32printf("s5:%d\n"	,
    sizeof(structs5)); //12printf("s6:%d\n"	,
    sizeof(structs6)); //20printf("s7:%d\n"	,
    sizeof(structs7)); //20system("pause"	)
    ;return0;}
    # include#
include

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

intmain 
() 
//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
{
    ;
    printf
    
    (
    
    "请输入你整型数组的元素总个数\n" n)
    ;scanf("%d",
    &);printf(n"n = %d\n",
    );//int parray[n];  //4种方式，3种合法，这种教材说非法intn*=
    (
    
    int *parray ) malloc( *sizeof(intn));//数组if(== NULL
    )printfparray ( "开辟空间失败！\n"){
        ;}int;for
    (
    
    = i0
    ;<i;++)iprintfn(i"请输入第%d个学生的成绩：",{
        (+1))i;scanf("%d",
        &[]);parray}ifor(=
    0
    
    ;<i;++)iprintfn(i"第%d个学生的成绩是：%d\n",{
        (+1),i*++);}parraysystem("pause"
    )
    
    
    ;return0;}
    # include#
include

指针收官，如何定义

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

字符串的 *** 作

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

字符串api

//char* strcpy(char* dest, const char *src);char 
*; 
= (char*
{
    )
    malloc (strDest128
    strDest ) ;memset (,','128);//初始化，防止*strDest成为野指针
    char*strDest="胡宇 胡宇";strcpy(,   )
    
    ; //字符串复制函数strSrc puts ()
    
    ;strcpystrDest(strSrc,"huyu" )
    ;putsstrDest()
    
    ;memsetstrDest(,','sizeof
    ()strDest/sizeof
    
    ([strDest0]));strDest//重置strncpy(,strDest"clc hs",3);//char* strncpy(char *destinin,char *sourse,int maxlen);    //可选择复制的元素个数    puts
    ()strDest;char[ 128]=   "追西西科技 "
    ;strcatstrDest(,
    
    ) test;//追加在一个字符串的后面puts ( );
    char*test=strSrc"123";    char
    *=test"123";
    
    int =str1 strcmp (,
    ) ;str2 printf ("ret = %d\n"
    
    , ret ) ;ifstr1(str2==0    //字符串的比较，str1str2 ret=1, str1=str2 ret=0
    )printf("两个字符串一样！\n"ret);
    }ifret(!strcmp{
        (,))//!非0
    printf
    
    ("两个字符串一样！\n");}str1systemstr2("pause"{ )
        ;return0;}
    #
    
    
    include#include#include
    /*
函数原型：
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

字符串api2

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

;
char
* =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("%s\n",p);
        puts(p);
    }
    
    char str1[] = "Hello Word"; //windows环境下 要定义成数组的形态，否则崩溃，Linux环境下可以用指针的
    puts(strlwr(str1));
    puts(strupr(str1));
    */str //strtok字符串的分割 char *strtok(char *strings,const char *tokseps);chen,li,chen; char[
    ] =p "chen1,li,chen2,hu,yu" ;int
    =
    1
    
    
    ;
    char str2*[ 10 ];
    
    = i strtok (,
    "," )psubs;if(!=
    p NULL )printfstr2("第%d个字符串：%s\n",,
    );p [ -1{
        ]=;}iwhilep(1
        psubs)i=strtok( NULL p,
        ","
    );if({
        
        p != NULL)printf("第%d个字符串：%s \n",++
        
        ,)p ; [-{
            1]=;}ielsepprintf(
            psubs"没有子串了\n"i);break ; p}
        }int{
            ;for(=0
            ;<
        ;
    ++
    ) jputs
    ([j]);j}isystemj("pause"{
        );psubsreturnj0;}