c语言基础笔记

c的数据类型有：char （-128 到 127 或 0 到 255），unsigned char（0 到 255），signed char（-128 到 127）
int（-32,768 到 32,767 或 -2,147,483,648 到 2,147,483,647） ，unsigned char（同理），signed char（同理）
short（-32,768 到 32,767） unsigned short（0 到 65,535）
long（-2,147,483,648 到 2,147,483,647） unsigned long（0 到 4,294,967,295）

c的变量有：int float double char void

整数常量：int 整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。
float double 和java相同
char ‘’ 单引号加字符
“” 字符串

定义常量：const type variable = value;
#define identifier value
typedef unsigned char BYTE;
typedef 仅限于为类型定义符号名称，#define 不仅可以为类型定义别名，也能为数值定义别名，比如您可以定义 1 为 ONE。
typedef 是由编译器执行解释的，#define 语句是由预编译器进行处理的。

声明变量：extern（extern int ：声明一个int类型的变量）

C 存储类：auto 存储类是所有局部变量默认的存储类
register 存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个字），且不能对它应 用一元的 ‘&’ 运算符（因为它没有内存位置）。
static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰 局部变量可以在函数调用之间保持局部变量的值。
extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 extern 时，对于无法初始化的变量，会把变量名指 向一个之前定义过的存储位置。

c的快捷函数：sizeof()得到对象或类型的存储字节大小

C 函数：
return_type function_name( parameter list )
{
body of the function
}

C 作用域规则：
1，在函数或块内部的局部变量 函数内的变量
2，在所有函数外部的全局变量 函数外的变量（在函数内可以用）
3，在形式参数的函数参数定义中 同时存在函数内和函数外且名字相同的时候，函数处理变量时会优先处理函数内变量

C 数组：定义 type arrayName [ arraySize ];
定义并初始化double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};
取数组值double salary = balance[3];（3为下标，下标从0开始计数所以取出来的值为50.0）

C enum(枚举)：定义enum DAY
{
MON=1, TUE, WED, THU, FRI, SAT, SUN
} ;
取值 enum DAY day;
day = WED;
printf(“%d”,day);
遍历枚举
for (day = MON; day <= SUN; day++) {
printf(“枚举元素：%d \n”, day);
}

C 指针:
变量指针
int var_runoob = 10;
int p; // 定义指针变量
p = &var_runoob;
printf(“var_runoob 变量的地址： %p\n”, p);
函数指针
/ p 是函数指针 /
int ( p)(int, int) = & max; // &可以省略
int a, b, c, d;

		printf("请输入三个数字:");
		scanf("%d %d %d", & a, & b, & c);

		/* 与直接调用函数等价，d = max(max(a, b), c) */
		d = p(p(a, b), c); 

		printf("最大的数字是: %d\n", d);

C回调函数：
// 回调函数
void populate_array(int *array, size_t arraySize, int (*getNextValue)(void))
{
for (size_t i=0; i<arraySize; i++)
array[i] = getNextValue();
}

	// 获取随机值
	int getNextRandomValue(void)
	{
			return rand();
	}

	int main(void)
	{
			int myarray[10];
			/* getNextRandomValue 不能加括号，否则无法编译，因为加上括号之后相当于传入此参数时传入了 int , 而不是函数指针*/
			populate_array(myarray, 10, getNextRandomValue);
			for(int i = 0; i < 10; i++) {
    				printf("%d ", myarray[i]);
			}
			printf("\n");
			return 0;
	}

C中的字符串：声明char site[7] = {‘R’, ‘U’, ‘N’, ‘O’, ‘O’, ‘B’, ‘\0’}; // 末尾’\0’用于标记字符串的结束
操作函数：
strcpy(s1, s2); // 复制字符串 s2 到字符串 s1
strcat(s1, s2); // 连接字符串 s2 到字符串 s1 的末尾
strlen(s1); // 返回字符串 s1 的长度
strcmp(s1, s2); // 如果 s1 和 s2 是相同的，则返回 0；如果 s1<s2 则返回负数；如果 s1>s2 则返回正数
strchr(s1, ch); // 返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置
strstr(s1, s2); // 返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置

C 结构体: 结构：
struct tag {
member-list
member-list
member-list
…
} variable-list ;
定义：
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
} book;
//用SIMPLE标签的结构体，另外声明了变量t1、t2、t3
struct book t1, t2[20], *t3;

为变量赋值：
struct Books book1;
strcpy( book1.title, "C Programming");

调用变量：book1.title;

利用指针调用：
struct Books
{
	char  title[50];
	char  author[50];
	char  subject[100];
	int   book_id;
};

/* 函数声明 */
void printBook( struct Books *book );
int main( )
{
	struct Books Book1;        /* 声明 Book1，类型为 Books */
	struct Books Book2;        /* 声明 Book2，类型为 Books */

	/* Book1 详述 */
	strcpy( Book1.title, "C Programming");
	strcpy( Book1.author, "Nuha Ali"); 
	strcpy( Book1.subject, "C Programming Tutorial");
	Book1.book_id = 6495407;

	/* Book2 详述 */
	strcpy( Book2.title, "Telecom Billing");
	strcpy( Book2.author, "Zara Ali");
	strcpy( Book2.subject, "Telecom Billing Tutorial");
	Book2.book_id = 6495700;

	/* 通过传 Book1 的地址来输出 Book1 信息 */
	printBook( &Book1 );

	/* 通过传 Book2 的地址来输出 Book2 信息 */
	printBook( &Book2 );

	return 0;
}
void printBook( struct Books *book )
{
	printf( "Book title : %s\n", book->title);
	printf( "Book author : %s\n", book->author);
	printf( "Book subject : %s\n", book->subject);
	printf( "Book book_id : %d\n", book->book_id);
}

C 共用体： 共用体类型的变量可以存储一个整数、一个浮点数，或者一个字符串。
声明：union Data
{
int i;
float f;
char str[20];
};
赋值和访问：
union Data data;

	data.i = 10;
	data.f = 220.5;
	strcpy( data.str, "C Programming");

	printf( "data.i : %d\n", data.i);
	printf( "data.f : %f\n", data.f);
	printf( "data.str : %s\n", data.str);

C 位域： 结构：
struct 位域结构名
{

	位域列表

};
位域列表：type [member_name] : width ;
声明：
struct
{
	unsigned int age : 3;
} Age;
使用：
Age.age = 4;
printf( "Sizeof( Age ) : %d\n", sizeof(Age) );
printf( "Age.age : %d\n", Age.age );

Age.age = 7;
printf( "Age.age : %d\n", Age.age );

Age.age = 8; // 二进制表示为 1000 有四位，超出 无效
printf( "Age.age : %d\n", Age.age );



利用指针：
struct bs{
    		unsigned a:1;
    		unsigned b:3;
    		unsigned c:4;
	} bit,*pbit;

bit.a=1;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
	bit.b=7;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
	bit.c=15;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
	printf("%d,%d,%d\n",bit.a,bit.b,bit.c);    /* 以整型量格式输出三个域的内容 */
	pbit=&bit;    /* 把位域变量 bit 的地址送给指针变量 pbit */
	pbit->a=0;    /* 用指针方式给位域 a 重新赋值，赋为 0 */
	pbit->b&=3;    /* 使用了复合的位运算符 "&="，相当于：pbit->b=pbit->b&3，位域 b 中原有值为 7，与 3 作按位与运算的结果为 3（111&011=011，十进制值为 3） */
	pbit->c|=1;    /* 使用了复合位运算符"|="，相当于：pbit->c=pbit->c|1，其结果为 15 */

C读写：
int getchar(void) 函数从屏幕读取下一个可用的字符，并把它返回为一个整数。这个函数在同一个时间内只会读取一个单一的字符。您可以在循环内使用这个方法，以便从屏幕上读取多个字符。

int putchar(int c) 函数把字符输出到屏幕上，并返回相同的字符。这个函数在同一个时间内只会输出一个单一的字符。您可以在循环内使用这个方法，以便在屏幕上输出多个字符。

int c;

printf( “Enter a value :”);
c = getchar( );

printf( "\nYou entered: ");
putchar( c );
printf( “\n”);

char *gets(char *s) 函数从 stdin 读取一行到 s 所指向的缓冲区，直到一个终止符或 EOF。

int puts(const char *s) 函数把字符串 s 和一个尾随的换行符写入到 stdout。

char str[100];

printf( “Enter a value :”);
gets( str );

printf( "\nYou entered: ");
puts( str );

int scanf(const char *format, …) 函数从标准输入流 stdin 读取输入，并根据提供的 format 来浏览输入。

int printf(const char *format, …) 函数把输出写入到标准输出流 stdout ，并根据提供的格式产生输出。

char str[100];
int i;

printf( “Enter a value :”);
scanf(“%s %d”, str, &i);

printf( “\nYou entered: %s %d “, str, i);
printf(”\n”);

C 文件读写：
打开文件
格式：FILE *fopen( const char *filename, const char *mode );
十进制
r 打开一个已有的文本文件，允许读取文件。
w 打开一个文本文件，允许写入文件。如果文件不存在，则会创建一个新文件。在这里，您的程序会从文件的开头写入内容。如果文件存在，则该会被截断为零长度，重新写入。
a 打开一个文本文件，以追加模式写入文件。如果文件不存在，则会创建一个新文件。在这里，您的程序会在已有的文件内容中追加内容。
r+ 打开一个文本文件，允许读写文件。
w+ 打开一个文本文件，允许读写文件。如果文件已存在，则文件会被截断为零长度，如果文件不存在，则会创建一个新文件。
a+ 打开一个文本文件，允许读写文件。如果文件不存在，则会创建一个新文件。读取会从文件的开头开始，写入则只能是追加模式。
二进制
rb 打开一个已有的文本文件，允许读取文件。
wb 打开一个文本文件，允许写入文件。如果文件不存在，则会创建一个新文件。在这里，您的程序会从文件的开头写入内容。如果文件存在，则该会被截断为零长度，重新写入。
ab 打开一个文本文件，以追加模式写入文件。如果文件不存在，则会创建一个新文件。在这里，您的程序会在已有的文件内容中追加内容。
rb+ 打开一个文本文件，允许读写文件。
wb+ 打开一个文本文件，允许读写文件。如果文件已存在，则文件会被截断为零长度，如果文件不存在，则会创建一个新文件。
ab+ 打开一个文本文件，允许读写文件。如果文件不存在，则会创建一个新文件。读取会从文件的开头开始，写入则只能是追加模式。
关闭文件
fclose( FILE *fp );

写入文件
FILE *fp = NULL;
fp = fopen(“/tmp/test.txt”, “w+”); // 指定文件
fprintf(fp, “This is testing for fprintf…\n”); // 把一个字符串写入到文件中
fputs(“This is testing for fputs…\n”, fp); // 把字符串 s 写入到 fp 所指向的输出流中
fclose(fp); // 关流
读取文件
FILE *fp = NULL;
char buff[255];

fp = fopen(“/tmp/test.txt”, “r”);
fscanf(fp, “%s”, buff);
printf(“1: %s\n”, buff );

fgets(buff, 255, (FILE*)fp);
printf(“2: %s\n”, buff );

fgets(buff, 255, (FILE*)fp);
printf(“3: %s\n”, buff );
fclose(fp);

fgets()来从文件中读取字符串，但是在遇到第一个空格和换行符时，它会停止读取

C 内存管理:
1 void calloc(int num, int size);
在内存中动态地分配 num 个长度为 size 的连续空间，并将每一个字节都初始化为 0。所以它的结果是分配了 numsize 个字节长度的内存空间，并且每个字节的值都是0。
2 void free(void *address);
该函数释放 address 所指向的内存块,释放的是动态分配的内存空间。
3 void *malloc(int num);
在堆区分配一块指定大小的内存空间，用来存放数据。这块内存空间在函数执行完成后不会被初始化，它们的值是未知的。
4 void *realloc(void *address, int newsize);
该函数重新分配内存，把内存扩展到 newsize。