黑马程序员——枚举、预处理指令和递归

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

枚举类型：（和结构体、指针都经常用）适用于变量有固定取值的情况

定义类型：enum 变量名

#include <stdio.h>
int main()
{
// 定义枚举类型，假如只想在春夏秋冬之间取值
enum season
{
spring,
summer,
autumn,
winter
}; 

// 定义枚举变量
enum season s = summer;
return 0;
}

数据类型总结：

一、基本数据类型

 1、int

   long int、long：8个字节  %ld

   short int、short：2个字节%d  %i

   unsigned int、unsigned：4个字节%zd

   signed int、signed、int：4字节 %d  %i

2、float\double

float ：4个字节%f

double：8个字节%f  %.2f 输出两位小数

3、char  1个字节 %c  %d

  char类型保存在内存中的是它的ASCII值

 

二、构造类型

1、数组：只能由同一种类型组成

2、结构体：不同类型数据组成

 

三、指针类型：

变量的定义 int *p； 间接操作变量的值 int a = 10； p = &a; *p = 20;

 

 

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

预处理指令：（三种）把代码翻译成0和1之前执行的指令

所有的预处理指令都是以 # 号开头的。预处理指令的位置可以随意写。

作用域：从编写指令的那一行开始一直到文件结尾。取消指令用 #undef 变量名

1、宏定义：带参数和不带参数两种

   宏名一般用大写或者以k开头。例如：#define kCOUNT 4

#include <stdio.h>
#define N 4
int main()
{
int ages[N] = {15, 21, 35, 25};
#undef  N  // 取消定义
return 0；
}  

// 翻译前将N用4代替，但代码中“”内的N不会被替代

 // 带参数的宏定义：不用函数求两个数的和，带参数的宏比函数效率高。

#include <stdio.h>
#define sum((n1)+(n2))   // 一定要加括号，否则会造成结果不准确
int main()
{
int a = 10; int b = 20;
int c = sum(a, b);  // 将sum（a,b）转为 a+b
printf("%d\n", c);
return 0;
}

例如如果定义时不加括号：

#define pingfang(a) (a*a) // 宏定义函数pingfang，应该写为((a)*(a)) ，这样结果就是100了
#include <stdio.h>
int main()
{
    int c = pingfang(5+5);  //宏定义只是简单的替换，不参与运算，5+5*5+5=35
    printf("c is %d\n", c);
    return 0;
}

2、条件编译

#include <stdio.h>
#define A 10
int main()
{
  #if (A == 10)  printf("A的值是10\n");  

/* 预处理命令只能找预处理值，所以要用宏定义。如果在函数内定义一个 int a =10，无法调用  */

#elif (A == 5)   printf("A的值是5\n");
#else   printf("A是其他值\n");
#endif                //  一定要写这个结束语
return 0;}            // 如果A是10，则只是执行A==10的那一段代码，其他的都会消失。

3、文件包含 include（多文件团队开发）

    #include<>表示系统自带的文件#include “ ”表示自定义的文件

不允许循环包含，比如a.h包含b.h，b.h又包含a.h

typedef的使用：定义类型的（给类型符起别名的）

typedef 旧名称新名称； //新名称就相当于旧名称，替换使用

作用：给已经存在的类型起一个新名称，写起来方便省事

适用场合：基本数据类型；指针；结构体；枚举；指向函数的指针；指向结构体的指针

#include<stdio.h>
typedef int myint;  // 定义myint为整形 ，写在函数内也可以，只是作用域不同， （相当于给int起了一个外号）
typedef myint myint2; // 定义 myint2为整形
typedef char * str; // 给指针类型char *起一个新的名称str
int main()
{
int a; myint i = 10; myint2 c = 20;
str name = "jack";  // 相当于char *name = “jack”;
return 0;
}

 

定义结构体新类型的时候可以写为：

typedef struct student
{
int age;
} mystu;   // 相当于typedef struct student mystu;
mystu stu = {20};

定义枚举

enum sex {man,woman};
 typedef enum sex
{man,woman} mysex; mysex s = man

给一个指向函数的指针定义新类型

typedef int (*mypoint) (int, int);
mypoint p = sum;                  //  sum是一个函数，相当于int (*p)(int, int) = sum;

static和extern：

一、对函数的作用

外部函数：（extern）定义的函数能被本文件和其他文件访问。默认情况下所有函数都是外部函数。可以完整的定义和声明外部函数。不允许有同名的外部函数

内部函数：（static）定义的函数只能被本文件访问，其他不能访问 ，各自可以有同名的内部函数

二、对变量的作用：变量有局部变量和全局变量

全局变量又分两种：

1、外部变量：（extern）定义的变量能被本文件和其他文件访问。默认都是外部变量。两个文件中可以定义同一个变量，而且就是相当于一个变量。一个文件中也可以重复定义。加extern只是声明一个变量。

2、内部变量：（static）定义的变量只能被本文件访问，不能被其他文件访问。static int a；

 

static对局部变量的作用：延长局部变量的生命周期，程序结束的时候局部变量才会销毁。而且并没有改变局部变量的作用域。

static对局部变量修饰适用于某个函数调用频率高且内部某个变量值是固定不变的。提高性能。

例子：

#include <stdio.h>
void test()
{
int a = 0;
a++;
printf("a的值是%d\n", a);
static int b = 0;
b++;
printf("b的值是%d\n", b);

}
int main()
{
tes();
tes();
tes();
return 0;  // 打印出来a的值都是1.  而b的值递增1,2,3
}

递归：用在函数内的 （函数自己调用自己）

递归的条件：

1、函数自己调用自己

2、必须有一个明确的返回值

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

#include <stdio>
int pow2(int b, int n);
int main()
{
int c = pow2(2, 3);
return 0;
}

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

以上的函数 要用递归就要找出规律可写为：

int pow2(int b, int n)
{
   if(n == 0) return 1;  // 这句很重要
   return pow2(b, n-1) * b;
 }