C語言

基礎

關鍵字

typeof

int a = 5;
typeof(int *) var = &a;

數據類型變量

char   
unsigned char 
signed char
int
unsigned int
short
unsigned short
long
unsigned long

float             4
double            8
long double       16

void fuction(void);

void *ptr = malloc(12);


85         /* 十進制 */
0213       /* 八進制 */
0x4b       /* 十六進制 */
30         /* 整數 */
30u        /* 無符號整數 */
30l        /* 長整數 */
30ul       /* 無符號長整數 */

//定義常量
#defined a 100
const int a = 100;

存儲類

auto
register
static 
extern

變量自動auto  函數自動auto

auto int a;  == int a;

register int a;    //每次取值從內存去 編譯器不要優化
static int a;      //靜態變量 生命週期全局

static void fun();  //限制函數名稱作用域再本文件別的文件不能引用 避免命名空間污染

extern int a;      //變量a引用
extern void fun(); //引用別的文件的函數

數組

//一維數組
int array[4] = {1, 2, 3, 4}
int array[] = {1, 2, 3, 4};

int a = array[0]
//二維數組
int array[3][4] = {  
 {0, 1, 2, 3} ,   /*  初始化索引號爲 0 的行 */
 {4, 5, 6, 7} ,   /*  初始化索引號爲 1 的行 */
 {8, 9, 10, 11}   /*  初始化索引號爲 2 的行 */
};
int val = array[2][3];

//數組傳參
1.
void fun(int *array) 
{   
}
2.
void fun(int array[4])
{
}
3.
void fun(int array[])
{
}
常用1和3
//傳遞二維數組
int array[4][3] = {0};
void fun(int array[][3])
void fun(int (* p)[3]);  //數組指針  指向數組

fun(array);

數組相同於指針
一維數組
int array[5];
*(array + 1) ==  *(&array[0] + sizeof(array)) //*(&array[0] + 5) 

二維數組
int array[4][5];
*(array + 1) == *(&array[0] + sizeof(array)) //*(&array[0] + 20) 
三維
int array[3][4][5];
*(array + 1) == *(&array[0] + sizeof(array))  //*(&array[0] + 60) 
//指針+1內存增加指針指向數據類型長度


//函數返回數組
int * fun()
{
    static int array[10];
    return array;
}

//指向數組指針
int array[4] = {1, 2, 3, 4}
int *ptr = array;

int array[4][4]
int *ptr = array;
int (*p)[4] = array; 

枚舉

enum DAY {
    MON = 1,
    TUE
};

enum season {spring, summer=3, autumn, winter};
沒有指定值的枚舉元素，其值爲前一元素加 1。也就說 spring 的值爲 0，summer 的值爲 3，autumn 的值爲 4，winter 的值爲 5

enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
};
enum DAY day;

enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
} day;

指針

int *p;    //一級指針
int **p;   //二級指針

int (*p)[4]; //數組指針  就是 指針指向數組  數組存儲大小是4個單元
int *p[4];   //指針數組  4個指向int的指針    int a = 10; p[0] = &a;

int (*p)(int, int);   //函數指針 指向函數

int fun(int a, int b);
p = fun;

p(1, 2);//執行

typedef int (*fun_ptr)(int, int);

fun_ptr p = fun;  //別名定義

字符串

數組最後一個字節存儲  '\0'
char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

char str[] = "hello"  //自動添加 '\0'

結構體

//定義
1.
struct Books {
    char title[10];
    char author[10];
} book;
2.
struct Books book;
3.
typedef struct {
    char title[10];
    char author[10];
} Books;

Books book;
//初始化

Books book = {"c", "my"};
Books book = {.title = "c", .author = "my"};  //C風格
Books book = {title ： "c", author ： "my"};   //C++風格


結構體大小
1，每個結構體成員的起始地址爲該成員大小的整數倍，即int型成員的其實地址只能爲0、4、8等
2，結構體的大小爲其中最大成員大小的整數倍

共用體

共用體是一種特殊的數據類型，允許您在相同的內存位置存儲不同的數據類型。您可以定義一個帶有多成員的共用體，但是任何時候只能有一個成員帶有值。共用體提供了一種使用相同的內存位置的有效方式

union Data
{
   int i;
   float f;
   char  str[20];
};
 
int main( )
{
   union Data data;        
 
   printf( "Memory size occupied by data : %d\n", sizeof(data));
 
   return 0;
}
//20
//大小爲最大成員大小
big-endian和little-endian格式。在小端模式中，低位字節放在低地址，高位字節放在高地址；在大端模式中，低位字節放在高地址，高位字節放在低地址。

//大小端測試
#include<stdio.h>
union var{
        char c;
        int i;
};
int main(){
    union var data;
    data.c = 0x04;
    printf("%x\n",data.i);
    if(data.i == 0x04) {
        printf("小端");
    } else {
         printf("大端");
    }
}

REVERSED
#if defined(REVERSED)
    std::cout<< ("大端");
#else
    std::cout<<("小端");
#endif
    

變參數函數

double average(int num,...)
{
 
    va_list valist;
    double sum = 0.0;
    int i;
 
    /* 爲 num 個參數初始化 valist */
    va_start(valist, num);
 
    /* 訪問所有賦給 valist 的參數 */
    for (i = 0; i < num; i++)
    {
       sum += va_arg(valist, int);
    }
    /* 清理爲 valist 保留的內存 */
    va_end(valist);
 
    return sum/num;
}
 
int main()
{
   printf("Average of 2, 3, 4, 5 = %f\n", average(4, 2,3,4,5));
   printf("Average of 5, 10, 15 = %f\n", average(3, 5,10,15));
}

預處理器

#define Conn(x, y) x##y   //連接字符
#define ToString(x) #x    //轉化爲字符串

#define eprintf(format, ...) fprintf(stderr, format, ##__VA_ARGS__)

#ifdef DEF     ==  #if define(DEF)

#else

#endif


#ifndef DEF

#endif

指令	描述
#define	定義宏
#include	包含一個源代碼文件
#undef	取消已定義的宏
#ifdef	如果宏已經定義，則返回真
#ifndef	如果宏沒有定義，則返回真
#if 	如果給定條件爲真，則編譯下面代碼
#else	#if 的替代方案
#elif	如果前面的 #if 給定條件不爲真，當前條件爲真，則編譯下面代碼
#endif	結束一個 #if……#else 條件編譯塊
#error	當遇到標準錯誤時，輸出錯誤消息
#pragma	使用標準化方法，向編譯器發佈特殊的命令到編譯器中

內存管理

void *calloc(int num, int size);  //分配並初始化爲 size

void free(void * address);        //釋放內存
void *malloc(int num)             //分配內存

void *realloc(void *address, int newsize); //擴展大小

位域

struct bs
{
    unsigned a:4;
    unsigned :0;
    unsigned b:4;
    unsigned c:4;
}

0填充對其
單個位域 最大8byte
整個結構體的總大小爲最寬基本類型成員大小的整數倍

位域變量類型：int unsigned int signed int

庫函數

stdio.h

int printf(const char *format, ...)


%d      有符號10進制  正數不帶符號位
%o      無符號8進制
%x,X    無符號16進制
%u      無符號十進制
%f      浮點數
%e,E    指數形式浮點數
%c      單個字符
%s      字符串
%p      指針
%lu     32位無符號
%llu    64位無符號

%+d     顯示+/-
%-d     左對齊 
%02X    填充 0 寬度2  默認填充空格
%-05X   左對齊

%#x    顯示0x
%#f    顯示一個小數

%*s, len, str   參數指定長度
%.2f   兩位小數
%lf    雙精度浮點數
%hd    短整型 short

 數據結構和算法

 

數據結構

 

算法

冒泡排序

void bubble_sort(int array[], int len)
{
    if(len == 0 || len == 1) {
        return;
    }
    len = len - 1;    //len - 1次排序就夠了 
    for(int i = 0; i < len; i++) {
        for(int j = 0; j < len - i; j++) {
            if(array[j] > array[j + 1]) {
                array[j] = array[i] + (array[i] = array[j]) * 0; //交換變量
            }
        }
    }
}

int main()
{
    int array[] = {22, 45, 56, 12, 35, 45, 7, 90};
    int len = sizeof(array) / sizeof(int);
    bubble_sort(array, len);

    for(int i = 0; i < len; i++) {
        printf("%d ", array[i]);
    }
    return 0;
}