C语言-07其它相关

预处理指令

/*  不带参数的宏定义
 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] = {, , , };

    for ( int i = ; i<COUNT; i++) {
        printf("%d\n", ages[i]);
    }

    // 从这行开始，COUNT这个宏就失效
#undef COUNT

    int a = COUNT;

    return ;
}

/*
 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(+)/pingfang();

    printf("c is %d\n", c);
    /*
    int c = sum(2, 3) * sum(6, 4);  //注意如果宏定义中后面的值如果不加括号计算结果是不正确的   2+3*6+4 =24 应该是50 宏加了括号 （2+3）* （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 ;
}

条件编译

#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 ;
}

typedef

/*
 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 = {};

    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 ;
}

typedef使用注意

#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 ;
}

include

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

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

#include <stdio.h>

int main()
{
    int c = sum(, );

    printf("c is %d\n", c);

    return ;
}

#ifndef LISI_H
#define LISI_H

int sum(int a, int b);

#endif

static与extern对函数的作用

/*
 外部函数：定义的函数能被本文件和其他文件访问
 1> 默认情况下所有函数都是外部函数
 2> 不允许有同名的外部函数

 内部函数：定义的函数只能被本文件访问，其他文件不能访问
 1> 允许不同文件中有同名的内部函数

 static对函数的作用：
 1> 定义一个内部函数
 2> 声明一个内部函数

 extern对函数的作用：
 1> 完整地定义一个外部函数
 2> 完整地声明一个外部函数
 (extern可以省略，默认情况下声明和定义的函数都是外部函数)
 */

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

//void test2();

int main()
{
    test();

    //test2();
    return ;
}

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

}

#include <stdio.h>

// 声明一个内部函数
static void test2();

// 完整地定义一个外部函数
/*
extern void test()
{
    printf("调用了test函数\n");
}*/
// 默认情况下，所有的函数都是外部函数，所以可以省略extern
void test()
{
    printf("调用了test函数\n");

    test2();
}

// 定义一个内部函数
static void test2()
{
    printf("调用了test2函数\n");
}

static与extern对变量的作用

/*
 全局变量分2种：
 外部变量：定义的变量能被本文件和其他文件访问
 1> 默认情况下，所有的全局变量都是外部变量
 1> 不同文件中的同名外部变量，都代表着同一个变量

 内部变量：定义的变量只能被本文件访问，不能被其他文件访问
 1> 不同文件中的同名内部变量，互不影响

 static对变量的作用：
 定义一个内部变量

 extern对变量的作用：
 声明一个外部变量

 static对函数的作用：
 定义和声明一个内部函数

 extern对函数的作用：
 定义和声明一个外部函数（可以省略）
 */
#include <stdio.h>

void test();

// 定义一个外部变量

//int a;   如果是全局变量，这么多个a都是代表同一个a
//int a;   前面默认可不是extern  如果a放到函数的后边，函数前用 extern int a 是声明变量 其它外部文件中定义 int a和它也是一个
//int a;
//int a;
//int a;

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

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

int main()
{
    //b = 10;

    //test();

    extern int a;
    a = ;

    /*
    a = 10;

    test();

    printf("a的值是%d\n", a);*/

    return ;
}

int a;

#include <stdio.h>

int a;

static int b;

void test()
{
    printf("b的值是%d\n", b);

    /*
    printf("a的值是%d\n", a);

    a = 20;*/
}

static与局部变量

#include <stdio.h>

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

void test()
{
    static double pi = 3.14;

    double zc =  * pi * ;

    int a = ;
    a++;
    printf("a的值是%d\n", a); //

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

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

    test();

    test();

    test();

    return ;
}

递归

/*
设计一个函数，用来计算b的n次方

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

int main()
{
    int c = pow2(, );

    printf("%d\n", c);
    return ;
}

/*
 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 <= ) return ;
    return pow2(b, n-) * 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;
}*/