gudako's memo

一、字符串的字面量

像”ABC”这样带双引号的一系列字符称为字符串字面量。

在字符串字面量的末尾会被加上一个叫做null字符的值为0的字符。用八进制转义字符表示null字符就是’\0’。

null字符的每一位都是0。若不用字符常量，而用整数常量表示就是0。

如果要在字符串字面量中表示双引号”，就需要使用转义字符\”。例如要表示 XY”Z的字符串字面量就必须写作”XY”Z”。

 

二、字符串

字符串的字面量类似于整数的50、浮点数的3.14等常量。数值型数据可以通过变量（对象）的数据类型转换进行混合运算。而表示字符序列的字符串（string）也可以以对象形式保存并灵活处理。

C语言中的字符串是以字符序列，即字符数组实现的。例如要表示字符串”ABC”，数组元素必须按以下顺序依次保存：

“A”、”B”、”C”、”\0”

末尾的null字符”\0″是字符串结束的标志。

 

三、字符数组的初始化赋值

有三种赋值方式：

	char str[5];

	str[0] = 'A';
	str[1] = 'B';
	str[2] = 'C';
	str[3] = 'D';
	str[4] = '\0';

 

	char str[5] = {'A','B','C','D','\0'};

 

	char str[5] = "ABCD";

 

在声明中，元素数可以省略。此时，数组str的元素数视为5。

	char str[] = "ABCD";

 

一、按位运算符

按位与运算符	&	a & b	按位计算a和b的逻辑与
按位或运算符	|	a | b	按位计算a和b的逻辑或
按位异或运算符	~	a ~ b	按位计算a和b的逻辑异或（相同为0，不同为1）

 

二、逻辑运算符

逻辑与运算符	&&	a && b	对操作数的值进行逻辑与运算
逻辑或运算符	||	a || b	对操作数的值进行逻辑或运算

十进制常量

日常生活中使用的10、57等整型常量成为十进制常量。

 

八进制常量

以0开头，以区别十进制常量。

12 —— 十进制常量（十进制的12）

012 —— 八进制常量（十进制的10）

 

十六进制常量

以0x或者0X开头。A~F不区分大小写。

0xA —— 十六进制常量（十进制的10）

0x12 —— 十六进制常量（十进制的18）

一、sizeof运算符

C语言中将表示字符的char型长度定义为1。

通过是用sizeof运算符（sizeof operator），写作sizeof(数据类型名称)可以判断出包括char型在内的所有数据类型的长度。

 

该运算符不仅仅是上面这种形式，还可以像这样使用：sizeof （表达式）

要判断数据类型的长度时使用前者，要判断变量或表达式的长度时使用后者。

 

#include <stdio.h>

int main(int argc, char *argv[])
{
	int a,b;
	char x,y;

	printf("sizeof(int) = %d\n", sizeof(int));
	printf("sizeof(char) = %d\n", sizeof(char));

	printf("sizeof(a) = %d\n", sizeof(a));
	printf("sizeof(x) = %d\n", sizeof(x));

	printf("sizeof(a + b) = %d\n", sizeof(a + b));
	printf("sizeof(x + y) = %d\n", sizeof(x + y));
	printf("sizeof(a + x) = %d\n", sizeof(a + x));

	return 0;
}

 

sizeof亦可求数组长度以及数组元素个数：

#include <stdio.h>

int main(int argc, char *argv[])
{
	int str[5];

	printf("sizeof(str) = %d\n", sizeof(str));
	printf("sizeof(str) / sizeof(str[0]) = %d\n", sizeof(str) / sizeof(str[0]));

	return 0;
}

 

 

二、sizeof_t和typedef声明

由sizeof运算符生成的值的数据类型是在<stddef.h>头文件中定义的size_t型，在许多编译器中用typedef声明来定义size_t型。

typedef unsigned size_t;

typedef声明是数据类型的同义词，也就是为现有的数据类型创建别名（并非创建新的数据类型）。

通过这个声明，size_t就成了unsigned型的同义词。

这个同义词在语法上可以作为一种“数据类型名称”来使用。

sizeof运算符是不会生成负值的，所以将它定义为无符号整型。

 

printf函数中的“%lu”转换说明表示unsigned long型数值，“%u”转换说明则是表示unsigned型数值。

格式控制字符串中的转换说明必须和要显示的值的数据类型保持一致。

一、字符型和整型

字符型和整型是用来表示“一定的数值范围”的整数数据类型的。

char	0 – 255
signed char	-128 – 127
unsigned char	0 – 255
signed int	-2147483648 ~ 2147483647
signed long int	-2147483648 ~ 2147483647
unsigned int	0 – 4294967295
unsigned long int	0 – 4294967295

 

二、字符型

char型是用来保存“字符”的数据类型。

一、基本数据类型

整型，浮点型，字符型，枚举型。

 

二、基数

二进制，八进制，十进制，十六进制。

 

三、基数转换

1.将二进制数101转换为十进制数的步骤：

101 = 1 x 2² + 0 x 2² + 1 x 2²

= 5

2.将十六进制数1FD转换为十进制的步骤：

1FD = 1 x 16² + 15 x 16² + 13 x 16²

= 509

3.将八进制数123转换为十进制数的步骤：

123 = 1 x 8² + 2 x 8² + 3 x 8²

= 83

 

由十进制数向二进制数转换

二进制数有以下规律：

偶数的末尾数字为0，

奇数的末尾数字为1。

即用要转换的十进制数除以2所得的余数就是末位数字的值。

 

#include <stdio.h>
#include <Windows.h>									//调用Windows API需要加此头文件

int main(int argc, char *argv[])						
{
	HANDLE hFile;												
	HANDLE hAppend;										//声明句柄变量
	DWORD  dwBytesRead, dwBytesWritten, dwPos;			//DWORD等同于无符号的int
	BYTE   buff[4096];									//声明数组，该数组申请的内存空间为4096个字节

	hFile = CreateFile(TEXT("E:\\file1\\file1_1.txt"),	//注意Visual环境下路径的单个\为转义字符
		GENERIC_READ,											
		0,
		NULL,
		OPEN_EXISTING,
		FILE_ATTRIBUTE_NORMAL,
		NULL);											//注意被调用函数的参数个数不能少
	
	if (hFile == INVALID_HANDLE_VALUE)
	{
		printf("Could not open file1_1.txt.");

		return 0;										//返回值的类型要与调用其函数的类型相同
	}

	hAppend = CreateFile(TEXT("E:\\file1\\file1_2.txt"),
		FILE_APPEND_DATA,
		FILE_SHARE_READ,
		NULL,
		OPEN_ALWAYS,
		FILE_ATTRIBUTE_NORMAL,
		NULL);

	if (hAppend == INVALID_HANDLE_VALUE)
	{
		printf("Could not open file1_2.txt.");

		return 0;
	}

	while (ReadFile(hFile, buff, sizeof(buff), &dwBytesRead, NULL)
		&& dwBytesRead > 0)
	{
		dwPos = SetFilePointer(hAppend, 0, NULL, FILE_END);
		LockFile(hAppend, dwPos, 0, dwBytesRead, 0);
		WriteFile(hAppend, buff, dwBytesRead, &dwBytesWritten, NULL);
		UnlockFile(hAppend, dwPos, 0, dwBytesRead, 0);
	}

	CloseHandle(hFile);
	CloseHandle(hAppend);

	return 0;
}

 

#include <stdio.h>
#include <Windows.h>
#include <TlHelp32.h>

int main(int argc, char *argv[])
{
	HANDLE SnapshotHandle;
	PROCESSENTRY32 ProcessEntry;
	BOOL Result;
	
	SnapshotHandle = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS,0);

	if (INVALID_HANDLE_VALUE == SnapshotHandle)
	{
		return 0;
	}
	
	ProcessEntry.dwSize = sizeof(PROCESSENTRY32);
	Result = Process32First(SnapshotHandle, &ProcessEntry);
	while (Result)
	{
		printf("ProcessID = %d, ProcessName = %s\r\n", ProcessEntry.th32ParentProcessID, ProcessEntry.szExeFile);
		Result = Process32Next(SnapshotHandle, &ProcessEntry);
	}

	return 0;
}

 

练习：输入一个整数。如果是该整数为奇数则乘以2；为偶数则除以2。

#include <stdio.h>

void mul(int x, int *y)
{
	*y = x * 2;
}

void div(int x, int *y)
{
	*y = x / 2;
}

int main(int argc, char *argv[])
{
	int a;
	int b;
	printf("请输入一个整数：");
	scanf("%d", &a);

	if (a % 2 != 0)
	{
		mul(a, &b);
		printf("乘以2等于%d。\n", b);
	}
	else
	{
		div(a, &b);
		printf("除以2等于%d。\n", b);
	}

	return 0;

 

一、一维数组

1.无初始值

int arr[100];

其中int表示整形，arr是数组的名字，[100]表示这是一个有100个int型变量的数组。即，内存为该数组分配了400个字节的空间。

2.赋予初始值

int arr[5] = {1,2,3,4,5};

其等同于

int arr[5];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
arr[3] = 4;
arr[4] = 5;

3.声明一维数组清零并访问

#include <stdio.h>

int main(int argc, char *argv[])
{
	int len = 10;
	int arr[10];
	for (int a = 0; a < 10; a++)
	{
		arr[a] = 0;
	}
	for (int i = 0; i < len; i++)
	{
		printf("index %d,and value is %d\n", i, arr[i]);
	}
	
	return 0;
}

 

二、二维数组

声明二维数组，清零并访问。

#include <stdio.h>

int main(int argc, char *argv[])
{
	int arr[3][4];
	//clear arr
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			arr[i][j] = 0;
		}			
	}
	//access arr
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			printf("index(%d,%d),%d\n",i,j,arr[i][j]);
		}
	}

	return 0;
}

 

声明二维数组并赋初始值。

int arr[3][4] = 
{
	{1,2,3,4},
	{5,6,7,8},
	{9,10,11,12}
};

 

三、字符数组

char arr[] = "gudako";

其等同于

char arr[] = { 'g','u','d','a','k','o','\0'};

表示内存为该数组分配了7个字节的空间。