c_语法入门_day6

最新推荐文章于 2023-08-16 08:00:00 发布

pre_eminent

最新推荐文章于 2023-08-16 08:00:00 发布

阅读量803

点赞数

分类专栏： # 待整理C 文章标签： c 入门

本文链接：https://blog.csdn.net/pre_eminent/article/details/25718273

版权

待整理C 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

H:/C语言入门/__day_6/01-返回指针的函数.c

#include <stdio.h>
char *test();

/*
 只要求能看懂
 */

int main()
{
    char *name = test();
    
    printf("name=%s\n", name);
    
    return 0;
}

char *test()
{
    return "rose";
}

H:/C语言入门/__day_6/02-指向函数的指针.c

#include <stdio.h>


double haha(double d, char *s, int a)
{
    
}

/*
 掌握：
 1.看懂语法
 2.定义指向函数的指针
    double (*p)(double, char *, int);
    p = haha;
    或者
    double (*p)(double, char *, int) = haha;
 3.如何间接调用函数
 1> p(10.7, "jack", 10);
 2> (*p)(10.7, "jack", 10);
 */

void test()
{
    printf("调用了test函数\n");
}

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

int main()
{
    // 定义指针变量指向sum函数
    // 左边的int：指针变量p指向的函数返回int类型的数据
    // 右边的(int, int)：指针变量p指向的函数有2个int类型的形参
    int (*p)(int, int);
    
    p = sum;
    
    //int c = p(10, 11);
    
    //int c = (*p)(10, 11);
    
    int c = sum(10, 9);
    
    printf("c is %d\n", c);
    
    
    return 0;
}


void test1()
{
    // (*p)是固定写法，代表指针变量p将来肯定是指向函数
    // 左边的void：指针变量p指向的函数没有返回值
    // 右边的()：指针变量p指向的函数没有形参
    void (*p)();
    
    // 指针变量p指向了test函数
    p = test;
    
    p();
    //(*p)(); // 利用指针变量间接调用函数
    
    //test(); // 直接调用函数
}

H:/C语言入门/__day_6/03-变量类型.c

/*
根据变量的作用域，可以分为：
 1.局部变量：
 1> 定义：在函数（代码块）内部定义的变量(包括函数的形参)
 2> 作用域：从定义变量的那一行开始，一直到代码块结束
 3> 生命周期：从定义变量的那一行开始分配存储空间，代码块结束后，就会被回收
 4> 没有固定的初始值
 
 2.全局变量
 1> 定义：在函数外面定义的变量
 2> 作用域：从定义变量的那一行开始，一直到文件结尾(能被后面的所有函数共享)
 3> 生命周期：程序一启动就会分配存储空间，程序退出时才会被销毁
 4> 默认的初始值就是0
*/
#include <stdio.h>

int age;

void test()
{
    int age;
    age = 10;
}

int main()
{
    printf("%d\n", age);// 0
    
    int age = 20;
    
    printf("%d\n", age);// 20
    
    test();
    
    printf("%d\n", age);// 20
    return 0;
}

H:/C语言入门/__day_6/04-变量类型练习.c

// 全局变量：a、b、c
// 局部变量：v1、v2、e、f

#include <stdio.h>
// 变量a的初值是10
int a = 10;

// 变量b的初值是0
// 变量c的初值是20
int b , c = 20;

int sum(int v1, int v2)
{
    return v1 + v2;
}

void test()
{
    b++;
    
    int i = 0;
    i++;
    
    printf("b=%d, i=%d\n", b, i);
}

int main()
{
    test();
    test();
    test();
    
    int e = 10;
    
    {
        {
            int f = 30;
        }
    }
    
    return 0;
}

H:/C语言入门/__day_6/05-结构体.c

/*
 数组：只能由多个相同类型的数据构成
 
 结构体：可以由多个不同类型的数据构成
 */
#include <stdio.h>

int main()
{
    //int ages[3] = {[2] = 10, 11, 27};
    
    
    //int ages[3] = {10, 11, 29};
    
    // 1.定义结构体类型
    struct Person
    { // 里面的3个变量，可以称为是结构体的成员或者属性
        int age; // 年龄
        double height; // 身高
        char *name; // 姓名
    };
    
    // 2.根据结构体类型，定义结构体变量
    struct Person p = {20, 1.55, "jack"};
    p.age = 30;
    p.name = "rose";
    
    printf("age=%d, name=%s, height=%f\n", p.age, p.name, p.height);
    
    /* 错误写法
    struct Person p2;
    p2 = {30, 1.67, "jake"};
    */
    
    struct Person p2 = {.height = 1.78, .name="jim", .age=30};
    //p2.age = 25;
    
    return 0;
}

H:/C语言入门/__day_6/06-结构体内存分析.c

#include <stdio.h>
int main()
{
    
    
    return 0;
}

// 补齐算法
void test1()
{
    struct Student
    {
        int age;// 4个字节
        
        char a;
        
        //char *name; // 8个字节
    };
    
    struct Student stu;
    //stu.age = 20;
    //stu.name = "jack";
    // 补齐算法（对齐算法）
    // 结构体所占用的存储空间 必须是 最大成员字节数的倍数
    
    int s = sizeof(stu);
    printf("%d\n", s);
}

// 结构体内存细节
void test()
{
    // 1.定义结构体类型(并不会分配存储空间)
    struct Date
    {
        int year;
        int month;
        int day;
    };
    
    // 2.定义结构体变量（真正分配存储空间）
    struct Date d1 = {2011, 4, 10};
    
    
    struct Date d2 = {2012, 8, 9};
    
    // 会将d1所有成员的值对应地赋值给d2的所有成员
    d2 = d1;
    d2.year = 2010;
    
    printf("%d - %d - %d\n", d1.year, d1.month, d1.day);
    
    printf("%d - %d - %d\n", d2.year, d2.month, d2.day);
    /*
     printf("%p - %p - %p\n", &d1.year, &d1.month, &d1.day);
     
     int s = sizeof(d1);
     printf("%d\n", s);
     
     */
}

H:/C语言入门/__day_6/07-结构体注意点.c

#include <stdio.h>

/*
 1.定义结构体变量的3种方式
 1> 先定义类型，再定义变量（分开定义）
 struct Student
 {
    int age;
 };
 struct Student stu;
 
 2> 定义类型的同时定义变量
 struct Student
 {
    int age;
 } stu;
 struct Student stu2;
 
 3> 定义类型的同时定义变量（省略了类型名称）
 struct
 {
    int age;
 } stu;
 
 2.结构体类型的作用域
 1> 定义在函数外面：全局有效（从定义类型的那行开始，一直到文件结尾）
 2> 定义在函数（代码块）内部：局部有效（从定义类型的那行开始，一直到代码块结束）
 */

// 从这行开始，一直到文件结尾，都是有效（跟全局变量一样）
struct Date
{
    int year;
    int month;
    int day;
};

int a;

void test2()
{
    struct Date
    {
        int year;
    };
    // 这里使用的是test2函数内部的struct Date类型
    struct Date d1 = {2011};
    
    
    // 结构体类型也是有作用域，从定义类型的那一行开始，一直到代码块结束
    struct Person
    {
        int age;
    };
    
    struct Person p;
    
    a  = 10;
}

int main()
{
    struct Date d1 = {2009, 8, 9};
    
    
    test2();
    
    // 不能使用test2函数中定义的类型
    // struct Person p2;
    
    return 0;
}

// 定义结构体变量
void test()
{
    // 定义结构体变量的第3种方式
    struct {
        int age;
        char *name;
    } stu;
    
    struct {
        int age;
        char *name;
    } stu2;
    
    
    /*结构体类型不能重复定义
     struct Student
     {
     int age;
     };
     
     struct Student
     {
     double height;
     };
     
     struct Student stu;
     */
    
    /* 错误写法：结构体类型重复定义
     struct Student
     {
     int age;
     double height;
     char *name;
     } stu;
     
     struct Student
     {
     int age;
     double height;
     char *name;
     } stu2;c
     */
    
    /*
     这句代码做了两件事情
     1.定义结构体类型
     2.利用新定义好的类型来定义结构体变量
     */
    // 定义变量的第2种方式：定义类型的同时定义变量
    /*
     struct Student
     {
     int age;
     double height;
     char *name;
     } stu;
     
     struct Student stu2;
     */
    
    /*
     // 定义变量的第1种方式：
     // 1.类型
     struct Student
     {
     int age;
     double height;
     char *name;
     };
     
     // 2.变量
     struct Student stu = {20, 1.78, "jack"};
     */
}

H:/C语言入门/__day_6/08-结构体数组.c

int main()
{
    struct RankRecord
    {
        int no; // 序号  4
        int score; // 积分 4
        char *name; // 名称 8
    };
    /*
    struct RankRecord r1 = {1, "jack", 5000};
    struct RankRecord r2 = {2, "jim", 500};
    struct RankRecord r3 = {3, "jake",300};
    */
    
    //int ages[3] = {10, 19, 29};
    
    //int ages[3];
    // 对齐算法
    // 能存放3个结构体变量，每个结构体变量占16个字节
    // 72
    /*
     int no; // 序号  4
     char *name; // 名称 8
     int score; // 积分 4
     */
    // 48
    /*
     int no; // 序号  4
     int score; // 积分 4
     char *name; // 名称 8
     */
    struct RankRecord records[3] =
    {
        {1, "jack", 5000},
        
        {2, "jim", 500},
        
        {3, "jake",300}
    };
    
    records[0].no = 4;
    // 错误写法
    //records[0] = {4, "rose", 9000};
    
    for (int i = 0; i<3; i++)
    {
        printf("%d\t%s\t%d\n", records[i].no, records[i].name, records[i].score);
    }
    
    //printf("%d\n", sizeof(records));
    
    
    return 0;
}

H:/C语言入门/__day_6/09-指向结构体的指针.c

#include <stdio.h>

/*
 1.指向结构体的指针的定义
 struct Student *p;
 
 2.利用指针访问结构体的成员
 1> (*p).成员名称
 2> p->成员名称
 
 */

int main()
{
    struct Student
    {
        int no;
        int age;
    };
    // 结构体变量
    struct Student stu = {1, 20};
    
    // 指针变量p将来指向struct Student类型的数据
    struct Student *p;
    
    // 指针变量p指向了stu变量
    p = &stu;
    
    p->age = 30;
    
    // 第一种方式
    printf("age=%d, no=%d\n", stu.age, stu.no);
    
    // 第二种方式
    printf("age=%d, no=%d\n", (*p).age, (*p).no);
    
    // 第三种方式
    printf("age=%d, no=%d\n", p->age, p->no);
    
    
    
    
    return 0;
}

H:/C语言入门/__day_6/10-结构体和函数.c

#include <stdio.h>
struct Student
{
    int age;
    int no;
};

// 如果结构体作为函数参数，只是将实参结构体所有成员的值对应地赋值给了形参结构体的所有成员
// 修改函数内部结构体的成员不会影响外面的实参结构体
void test(struct Student s)
{
    s.age = 30;
    s.no = 2;
}

// 会影响外面的实参结构体
void test2(struct Student *p)
{
    p->age = 15;
    p->no = 2;

}

void test3(struct Student *p)
{
    struct Student stu2 = {15, 2};
    p = &stu2;
    p->age = 16;
    p->no = 3;
}

int main()
{
    struct Student stu = {28, 1};
    
    //test(stu);
    //test2(&stu);
    test3(&stu);
    
    printf("age=%d, no=%d\n", stu.age, stu.no);
    
    return 0;
}

H:/C语言入门/__day_6/11-结构体补齐算法.c

#include <stdio.h>

int main()
{
    char c = 'A';
    
    int a = 10;
    
    printf("a=%p\n", &a);
    printf("c=%p\n", &c);
    
    
    /*
    struct Student
    {
        int age;// 4
        int score;// 4
        
        char *name;//8
    };
    
    struct Student stus[3];
    
    
    printf("%ld\n", sizeof(stus));*/
    
    return 0;
}

H:/C语言入门/__day_6/12-结构体的嵌套定义.c

#include <stdio.h>

int main()
{
    struct Date
    {
        int year;
        int month;
        int day;
    };
    
    
    // 类型
    struct Student
    {
        int no; // 学号
        
        struct Date birthday; // 生日
        
        struct Date ruxueDate; // 入学日期
        
        // 这种写法是错误的
        //struct Student stu;
    };
    
    
    struct Student stu = {1, {2000, 9, 10}, {2012, 9, 10}};
    
    printf("year=%d,month=%d,day=%d\n", stu.birthday.year, stu.birthday.month, stu.birthday.day);
    
    
    
    
    
    return 0;
}

H:/C语言入门/__day_6/13-枚举.c

#include <stdio.h>

int main()
{
    enum Sex { Man, Woman, Unkown};
    
    // 0男  1女 -1不详
    //int sex = 3;
    //enum Sex s = Unkown;
    
    // 1.定义枚举类型
    enum Season
    {
        spring = 1,
        summer,
        autumn,
        winter
    };
    
    // 2.定义枚举变量
    enum Season s = 100000;
    
    
    printf("%d\n", s);
    
    
    return 0;
}

H:/C语言入门/__day_6/14-宏定义.c

/*
 1.所有的预处理指令都是以#开头
 2.预处理指令分3种
 1> 宏定义
 2> 条件编译
 3> 文件包含
 3.预处理指令在代码翻译成0和1之前执行
 4.预处理的位置是随便写的
 5.预处理指令的作用域：从编写指令的那一行开始，一直到文件结尾，可以用#undef取消宏定义的作用
 6.宏名一般用大写或者以k开头，变量名一般用小写
 */
#include <stdio.h>


//#define kCount 4

int main()
{
    char *name = "COUNT";
    
    printf("%s\n", name);
    
    #define COUNT 4
    
    int ages[COUNT] = {1, 2, 67, 89};
    
    
    
    for ( int i = 0; i<COUNT; i++) {
        printf("%d\n", ages[i]);
    }
    
    // 从这行开始，COUNT这个宏就失效
#undef COUNT
    
    int a = COUNT;
    
    return 0;
}

void test()
{
    
}

H:/C语言入门/__day_6/15-宏定义2.c

/*
 1.带参数的宏定义效率比函数高
 
 */

/*
int sum(int a, int b)
{
    return a + b;
}*/
#include <stdio.h>

#define sum(v1, v2) ((v1)+(v2))

#define pingfang(a) ((a)*(a))

int main()
{
    // pingfang(5+5) (10*10)
    // pingfang(5+5)
    // pingfang(5+5) (35)
    // pingfang(5+5)/pingfang(2)
    int c = pingfang(5+5)/pingfang(2);
    
    printf("c is %d\n", c);
    /*
    int c = sum(2, 3) * sum(6, 4);
    
    printf("c is %d\n", c);*/
    /*
    int a = 10;
    
    int b = 20;
    
    
    int c = sum(a, b);
    
    printf("c is %d\n", c);
    //int c = sum(a, b);*/
    
    return 0;
}

H:/C语言入门/__day_6/16-条件编译.c

#include <stdio.h>

// 只要写了#if，在最后面必须加上#endif

//#define A 5

int main()
{
#ifndef A
//#ifdef A
//#if !defined(A)
    printf("哈哈\n");
#endif
    
    //int a = 10;
    /*
    if (a == 10)
    {
        printf("a是10\n");
    }
    else if (a == 5)
    {
        printf("a是5\n");
    }
    else
    {
        printf("a其他值\n");
    }*/
    /*
    
#if (A == 10)
    printf("a是10\n");
#elif (A == 5)
    printf("a是5\n");
#else
    printf("a其他值\n");
#endif
     
     */
    
    return 0;
}

H:/C语言入门/__day_6/18-typedef.c

/*
 1.作用：给已经存在的类型起一个新的名称
 
 2.使用场合：
 1> 基本数据类型
 2> 指针
 3> 结构体
 4> 枚举
 5> 指向函数的指针
 */

#include <stdio.h>

typedef int MyInt;
typedef MyInt MyInt2;

// 给指针类型char *起一个新的类型名称String
typedef char * String;

/*
struct Student
{
    int age;
};
typedef struct Student MyStu;
*/

/*
typedef  struct Student
{
    int age;
} MyStu;
*/


typedef struct
{
    int age;
} MyStu;

/*
enum Sex {Man, Woman};
typedef enum Sex MySex;
*/

typedef enum {
    Man,
    Woman
} MySex;


typedef int (*MyPoint)(int, int);

int minus(int a, int b)
{
    return a - b;
}

int sum(int a, int b)
{
    return a + b;
}
/*
struct Person
{
    int age;
};

typedef struct Person * PersonPoint;
*/

typedef struct Person
{
    int age;
} * PersonPoint;

int main()
{
    // 定义结构体变量
    struct Person p = {20};
    
    PersonPoint p2 = &p;
    
    //struct Person *p2 = &p;
    
    //MyPoint p = sum;
    //MyPoint p2 = minus;
    //int (*p)(int, int) = sum;
    
    //int (*p2)(int, int) = minus;
    
    //p(10, 11);
    
    
    //MySex s = Man;
    //enum Sex s = Man;
    //enum Sex s2 = Woman;
    
   // struct Student stu3;
    //MyStu stu = {20};
    //MyStu stu2= {21};
    
    return 0;
}

void test2()
{
    String name = "jack";
    
    printf("%s\n", name);
}

void test()
{
    int a;
    MyInt i = 10;
    MyInt2 c = 20;
    
    MyInt b1, b2;
    
    printf("c is %d\n", c);
}

H:/C语言入门/__day_6/19-typedef使用注意.c

#include <stdio.h>

//#define Integer int

//typedef int Integer;

//typedef unsigned long int MyInt;

#define String2 char *

typedef char * String;

int main()
{
    /*
    int a,b;
    int a;
    int b;
    */
    
    //s1、s2是char *指针
    String s1, s2;
    /*
     String s1;
     String s2;
     */
    s1 = "jack";
    s2 = "rose";
    
    // s3才是char *指针，s4只是char
    String2 s3, s4;
    /*
    char *s3, s4;
    char *s3;
    char s4;
    */
    //String2 s3 = "jake";
    
    /*
    String s1;
    String s2;
    */
    
    
    
    
    //Integer i = 10;
    
    return 0;
}

H:/C语言入门/__day_6/22-递归.c

/*
设计一个函数，用来计算b的n次方
 
 递归的2个条件：
 1.函数自己调用自己
 2.必须有个明确的返回值
*/
#include <stdio.h>
int pow2(int b, int n);

int main()
{
    int c = pow2(3, 2);
    
    printf("%d\n", c);
    return 0;
}

/*
 pow2(b, 0) == 1
 pow2(b, 1) == b == pow2(b, 0) * b
 pow2(b, 2) == b*b == pow2(b, 1) * b
 pow2(b, 3) == b*b*b == pow2(b, 2) * b
 
 1> n为0，结果肯定是1
 2> n>0，pow2(b, n) == pow2(b, n-1) * b
 */

int pow2(int b, int n)
{
    if (n <= 0) return 1;
    return pow2(b, n-1) * b;
}

/*
int pow2(int b, int n)
{
    // 用来保存计算结果
    int result = 1;
    
    
    //result *= b;
    //result *= b;
    //result *= b;
    //result *= b;
    //....
    
    //n次

    
    for (int i = 0; i<n; i++)
    {
        result *= b;
    }
    
    return result;
}*/

H:/C语言入门/__day_6/23-数据类型总结.c

一、基本数据类型
1.int
1> long int、long：8个字节  %ld
2> short int、short：2个字节 %d %i
3> unsigned int、unsigned：4个字节 %zd 
4> signed int、signed、int：4个字节 %d %i

2.float\double
1> float ：4个字节 %f
2> double：8个字节 %f

3.char
1> 1个字节 %c %d
2> char类型保存在内存中的是它的ASCII值
 'A' --> 65

二、构造类型
1.数组
1> 只能由同一种类型的数据组成
2> 定义：数据类型 数组名[元素个数];

2.结构体
1> 可以由不同类型的数据组成
2> 先定义类型，再利用类型定义变量

三、指针类型
1.变量的定义
int *p;

2.间接操作变量的值
int a = 10;
p = &a;
*p = 20;

四、枚举类型
使用场合：当一个变量只允许有几个固定取值时

H:/C语言入门/__day_6/24-include.c

/*
 1.<>表示系统自带的文件，""表示自定义的文件
 2.不允许循环包含，比如a.h包含b.h，b.h又包含a.h
 */

#include "lisi.h"
#include "wangwu.h"

#include <stdio.h>

int main()
{
    int c = sum(10, 19);
    
    printf("c is %d\n", c);
    
    return 0;
}

H:/C语言入门/__day_6/25-static和extern对函数的作用.c

/*
 外部函数：定义的函数能被本文件和其他文件访问
 1> 默认情况下所有函数都是外部函数
 2> 不允许有同名的外部函数
 
 内部函数：定义的函数只能被本文件访问，其他文件不能访问
 1> 允许不同文件中有同名的内部函数
 
 static对函数的作用：
 1> 定义一个内部函数
 2> 声明一个内部函数
 
 extern对函数的作用：
 1> 完整地定义一个外部函数
 2> 完整地声明一个外部函数
 (extern可以省略，默认情况下声明和定义的函数都是外部函数)
 */


// 声明一个test函数
// 完整地声明一个外部函数
// extern可以省略
//extern void test();
void test();

//void test2();

int main()
{
    test();
    
    //test2();
    return 0;
}

//void test()
//{
//    
//}
static void test2()
{
    
}

H:/C语言入门/__day_6/26-static和extern对全局变量的作用.c

/*
 全局变量分2种：
 外部变量：定义的变量能被本文件和其他文件访问
 1> 默认情况下，所有的全局变量都是外部变量
 1> 不同文件中的同名外部变量，都代表着同一个变量
 
 内部变量：定义的变量只能被本文件访问，不能被其他文件访问
 1> 不同文件中的同名内部变量，互不影响
 
 static对变量的作用：
 定义一个内部变量
 
 extern对变量的作用：
 声明一个外部变量
 
 static对函数的作用：
 定义和声明一个内部函数
 
 extern对函数的作用：
 定义和声明一个外部函数（可以省略）
 */
#include <stdio.h>

void test();

// 定义一个外部变量

//int a; 这么多个a都是代表同一个a
//int a;
//int a;
//int a;
//int a;


// 定义一个内部变量
static int b;

// 声明一个外部变量
//extern int a;

int main()
{
    //b = 10;
    
    //test();
    
    extern int a;
    a = 10;
    
    /*
    a = 10;
    
    test();
    
    printf("a的值是%d\n", a);*/
    
    return 0;
}


int a;

H:/C语言入门/__day_6/27-static与局部变量.c

#include <stdio.h>

/*
 static修饰局部变量的使用场合：
 1.如果某个函数的调用频率特别高
 2.这个函数内部的某个变量值是固定不变的
 */

void test()
{
    static double pi = 3.14;
    
    double zc = 2 * pi * 10;
    
    int a = 0;
    a++;
    printf("a的值是%d\n", a); // 1
    
    /*
     static修饰局部变量：
     1> 延长局部变量的生命周期：程序结束的时候，局部变量才会被销毁
     2> 并没有改变局部变量的作用域
     3> 所有的test函数都共享着一个变量b
     */
    static int b = 0;
    b++;
    printf("b的值是%d\n", b); // 3
}

int main()
{
    for (int i = 0; i<100; i++) {
        test();
    }
    
    
    test();
    
    test();
    
    test();
    
    
    return 0;
}