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

 

/*
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); //注意如果宏定义中后面的值如果不加括号计算结果是不正确的 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 0;
}

 条件编译

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

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

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

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(10, 19);

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

return 0;
}



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

//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
= 10;

/*
a = 10;

test();

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

return 0;
}


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

递归

/*
设计一个函数,用来计算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;
}
*/

 

本站声明
本文转载自:http://www.cnblogs.com/iedo/p/5048493.html     作者:呆而肥     发布日期:2015/12/15     本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。


 
© 2014-2017 ITdaan.com 粤ICP备14056181号