C 语言复习

C 语言,说什么都是多余的。

再复习一下:

// 单行注释 //

/*
多行
注释
*/

// 引用头文件
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// 声明函数
void function_1();
void function_2();

// 程序的入口是 main 函数, main 函数返回一个 int 型数值
int main() {

// 打印使用 printf 即,带格式的打印。
printf("%d\n", 0); // => Prints 0

// 所有的语句需要使用分号结尾

///////////////////////////////////////
// 类型
///////////////////////////////////////

// 使用变量前,必须先要声明。变量声明要明确变量类型。

// int 型一般是 4 个字节
int x_int = 0;

// short 型一般需要 2 个字节
short x_short = 0;

// char 型 1 个字节
char x_char = 0;
char y_char = 'y'; // 单个字符需要使用单引号包裹

// long 型是 4 或 8 字节,但是 long long 型一般都是 8 字节
long x_long = 0;
long long x_long_long = 0;

// float 一般是 32 位浮点数
float x_float = 0.0;

// double 一般是 64 位浮点数
double x_double = 0.0;

// unsigned 无符号型,非负
unsigned char ux_char;
unsigned short ux_short;
unsigned int ux_int;
unsigned long long ux_long_long;

// 使用 sizeof 或缺类型的实际长度
printf("%lu\n", sizeof(int)); // => 4 当前环境下 int 为 4 字节

// 数组必须以固定的长度声明
char my_char_array[20];
int my_int_array[20];



// 可以这样声明且初始化数组内所有值为 0
char my_array[20] = {0};

// 使用 [] 索引数组内的值
my_array[0]; // => 0

// 数组是可变的
my_array[1] = 2;
printf("%d\n", my_array[1]); // => 2

// 字符串就是以  结尾的字符数组
char a_string[20] = "This is a string";
printf("%s\n", a_string); // %s formats a string

/*
这个 a_string 长度为 16, 第 17 个 char 成员就是  , 18、19、20 数组位为未定义值
*/

printf("%d\n", a_string[16]); // => 0

///////////////////////////////////////
// 运算操作
///////////////////////////////////////

int i1 = 1, i2 = 2; // 多个变量声明初始化
float f1 = 1.0, f2 = 2.0;

// 数学计算
i1 + i2; // => 3
i2 - i1; // => 1
i2 * i1; // => 2
i1 / i2; // => 0 (取整)

f1 / f2; // => 0.5

// 取余运算
11 % 3; // => 2

// 比较操作
// 需要明确的是,C 语言中没有 bool 型数值, 0 即为假,其他任意值都为真
// 比较操作符一般返回 0 或 1
3 == 2; // => 0 (false)
3 != 2; // => 1 (true)
3 > 2; // => 1
3 < 2; // => 0
2 <= 2; // => 1
2 >= 2; // => 1

// 逻辑操作
!3; // => 0 (逻辑非)
!0; // => 1
1 && 1; // => 1 (逻辑与)
0 && 1; // => 0
0 || 1; // => 1 (逻辑或)
0 || 0; // => 0

// 位操作
~0x0F; // => 0xF0 (取非)
0x0F & 0xF0; // => 0x00 (位 AND)
0x0F | 0xF0; // => 0xFF (位 OR)
0x04 ^ 0x0F; // => 0x0B (位 XOR)
0x01 << 1; // => 0x02 (左移)
0x02 >> 1; // => 0x01 (右移)

///////////////////////////////////////
// 流程控制
///////////////////////////////////////

if (0) {
  printf("I am never run\n");
} else if (0) {
  printf("I am also never run\n");
} else {
  printf("I print\n");
}

// while 循环与退出
int ii = 0;
while (ii < 10) {
    printf("%d, ", ii++); // ii++ 在使用完 ii 以后递增 ii 的值
} // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "

printf("\n");

int kk = 0;
do {
    printf("%d, ", kk);
} while (++kk < 10); // ++kk 在使用 kk 之前就递增了 kk 的值
// => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "

printf("\n");

// For loops too
int jj;
for (jj=0; jj < 10; jj++) {
    printf("%d, ", jj);
} // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "

printf("\n");

///////////////////////////////////////
// 类型转换
///////////////////////////////////////

int x_hex = 0x01; // 十六进制的方式书写数值

// 类型转换的时候,其数值本身尽量保持不变
printf("%d\n", x_hex); // => Prints 1
printf("%d\n", (short) x_hex); // => Prints 1
printf("%d\n", (char) x_hex); // => Prints 1

// 溢出的时候不会有警告
printf("%d\n", (char) 257); // => 1 (Max char = 255)

// 整型与浮点型可以相互转换
printf("%f\n", (float)100); // %f formats a float
printf("%lf\n", (double)100); // %lf formats a double
printf("%d\n", (char)100.0);

///////////////////////////////////////
// 指针
///////////////////////////////////////

int x = 0;
printf("%p\n", &x); // 使用 & 获取一个变量的地址
// (%p 格式化输出一个指针)
// => 也就是输出一个变量的内存地址

// 声明指针
int* px; // px 指向 int 型变量指针
px = &x; // 保存 x 的指针到 px 中
printf("%p\n", px); // => 打印 px 保存的地址

printf("%d\n", *px); // => 打印出 0 ,也就是 x 的值,也就是 px 指针所指向的变量的值。

// 改变指针所指的变量的值
(*px)++; // px 所指的变量的值增加 1
printf("%d\n", *px); // => 1
printf("%d\n", x); // => 1

int x_array[20]; // 数组中的变量的内存地址是连续的。
int xx;
for (xx=0; xx<20; xx++) {
    x_array[xx] = 20 - xx;
} // 赋值 x_array 其中的值为 20, 19, 18,... 2, 1

// 声明一个 int 型指针,并且指向 x_array
int* x_ptr = x_array;
// x_ptr 现在就指向的 x_array 数组的第一个元素

// Arrays are pointers to their first element
printf("%d\n", *(x_ptr)); // => Prints 20
printf("%d\n", x_array[0]); // => Prints 20

// Pointers are incremented and decremented based on their type
printf("%d\n", *(x_ptr + 1)); // => Prints 19
printf("%d\n", x_array[1]); // => Prints 19

// You can also dynamically allocate contiguous blocks of memory with the
// standard library function malloc, which takes one integer argument
// representing the number of bytes to allocate from the heap.
int* my_ptr = (int*) malloc(sizeof(int) * 20);
for (xx=0; xx<20; xx++) {
    *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx would also work here
} // Initialize memory to 20, 19, 18, 17... 2, 1 (as ints)

// Dereferencing memory that you haven't allocated gives
// unpredictable results
printf("%d\n", *(my_ptr + 21)); // => Prints who-knows-what?

// When you're done with a malloc'd block of memory, you need to free it,
// or else no one else can use it until your program terminates
free(my_ptr);

// Strings can be char arrays, but are usually represented as char
// pointers:
char* my_str = "This is my very own string";

printf("%c\n", *my_str); // => 'T'

function_1();
} // end main function

///////////////////////////////////////
// 函数
///////////////////////////////////////

// 函数声明
// <return type> <function name>(<args>)

int add_two_ints(int x1, int x2){
    return x1 + x2; // 返回
}

/*
函数是指传递的,但是你可以通过传递指针来达到改变变量中值的目的。
*/

// void 函数,来逆序字符串
void str_reverse(char* str_in){
    char tmp;
    int ii=0, len = strlen(str_in);
    for(ii=0; ii<len/2; ii++){
        tmp = str_in[ii];
        str_in[ii] = str_in[len - ii - 1];
        str_in[len - ii - 1] = tmp;
    }
}

/*
char c[] = "This is a test.";
str_reverse(c);
printf("%s\n", c); // => ".tset a si sihT"
*/

///////////////////////////////////////
// 自定义类型与结构体
///////////////////////////////////////

// 使用 typedef 来定义基本变量的别名
typedef int my_type;
my_type my_type_var = 0;

// 结构体就是各种基本数据的集合
struct rectangle {
    int width;
    int height;
};


void function_1(){

    struct rectangle my_rec;

    // 使用 . 来获取结构体重的数据
    my_rec.width = 10;
    my_rec.height = 20;

    // 可以声明指向结构体的指针
    struct rectangle* my_rec_ptr = &my_rec;

    // Use dereferencing to set struct pointer members...
    (*my_rec_ptr).width = 30;

    // ... or use the -> shorthand
    my_rec_ptr->height = 10; // Same as (*my_rec_ptr).height = 10;
}

// You can apply a typedef to a struct for convenience
typedef struct rectangle rect;

int area(rect r){
    return r.width * r.height;
}

///////////////////////////////////////
// 函数指针
///////////////////////////////////////
/*
At runtime, functions are located at known memory addresses. Function pointers are
much likely any other pointer (they just store a memory address), but can be used
to invoke functions directly, and to pass handlers (or callback functions) around.
However, definition syntax may be initially confusing.

Example: use str_reverse from a pointer
*/
void str_reverse_through_pointer(char * str_in) {
    // Define a function pointer variable, named f.
    void (*f)(char *); // Signature should exactly match the target function.
    f = &str_reverse; // Assign the address for the actual function (determined at runtime)
    (*f)(str_in); // Just calling the function through the pointer
    // f(str_in); // That's an alternative but equally valid syntax for calling it.
}

/*
As long as function signatures match, you can assign any function to the same pointer.
Function pointers are usually typedef'd for simplicity and readability, as follows:
*/

typedef void (*my_fnp_type)(char *);

// The used when declaring the actual pointer variable:
// ...
// my_fnp_type f;