c基礎
C基本數據類型
char short int float long double
所佔字節 32和64位系統有所區別 sizeof()
數據結構
數組、鏈表、棧、隊列、tree
++i
i++
--i
運算符與優先級
循環結構、選擇結構
if(a<1){
xxx
}else if(a==1){
xxx
}else{
xxx
}
switch(a){ //a整形數據
case 1:
xxx
case 2:
xxx
case 3:
xxx
default:
xxx
}
for(int i=0;i<100;i++){
xxx
}
while(i<100){
xxxx
}
do{
xxx
}while(i<100)
int *p[]= {};
指針
內存的地址，C語言允許用一個變量來存放指針，這種變量稱爲指針變量。指針變量可以存放基本類型數據的地址，也可以存放數組、函數以及其他指針變量的地址。
-
常見指針變量的定義
char*p :p指向一個char型數據，也可以指向一個char[]數組 char**q :q爲一個二級指針，指向爲char*數據 int (*p)[] :數組指針，它是一個指針，指向的是int[]數組 int *p[] : 指針數組，它是一個數組，數組裏元素都是int* 型指針 int (*p)(int a, int b) :函數指針，本質爲一個指針，可以指向的是 int fun(int a,int b)類型的函數 int *p(int a, int b): 指針函數，本質是一個函數，返回的一個int*型數據
結構體
struct Stu{
char *name;
int num;
int age;
char group;
float score;
};
或
typedef struct{
char *name;
int num;
int age;
char group;
float score;
}Stu;
結構體變量必須初始化，malloc、new
C
Stu *stu = malloc(sizeof(Stu))
C++
Stu *stu = new Stu()
stu->age
stu.age
C內存佈局、分配方式
- 內存佈局
- 分配方式
一個程序本質上都是由 Bss 段、Data段、Text段三個組成的
- Text段
通常是指用來存放程序執行二進制代碼
- Bss段
一般是指用來存放程序中未初始化的全局變量
- Data段
包括三部分 heap(堆)、stack(棧)和靜態數據區。
-
堆（heap）:用於存放進程執行中被動態分配的內存段。它的大小並不固定，可動態擴張或縮減。malloc或new(C++)申請,需主動釋放free、delete,否則會造成內存泄漏
-
棧(stack)：編譯器自動分配釋放，存放函數傳參，局部變量，函數括弧“{}”中定義的變量（但不包含static聲明的變量。static意味着在數據段中存放變量
-
靜態數據區: 已初始化的全局變量、靜態變量和常量。
int a = 0; //全局初始化區，靜態數據區
char *p1; //全局未初始化區 bss段
char* func(){//寫法正確
char *str = "hello,world";
return str;
}
char* func1(){//寫法錯誤,數組是不能作爲函數返回值的，編譯器把數組名認爲是局部變量（數組）的地址，所以要用指針代替
char str[20] = "hello,world";//如果非要返回，可以用static修飾
return str;
}
char* func2(){
char *str = (char*)malloc(20);
str = "hello,world";
return str;//返回堆內存的指針
}
int main(int argc, const char*argv[])
{
static int a = 0; //全局（靜態）初始化區，靜態數據區
int b; //棧
char s[10] = "abc"; //字符串和s都是棧區，字符數組s在棧區分配內存
char *p3 = "bilei"; //"bilei"在常量區，p3在棧區
p2 = (char *)malloc(20); //分配成功堆區
//p2用完後必須主動釋放
free(p2);
p2=NULL;//防止產生野指針。所謂野指針，即它指向的內存已被釋放，單指針本身未釋放，它指向的一塊“垃圾”
}
彙編
常用指令
push、pop、add、sub、mov、lea、ldr、str、cmp、bl、blx、call(x86)
ret
push 壓棧 pusb rbp
pop 出站. pop rbp
add :add eax,2 //eax = eax+2
sub :sub eax,2 //eax = eax-2
mov :賦值指令
ldr :讀取
str :存儲
mov R0, 1 //將0賦值給寄存器r0
LDR R0,[R1] // 將存儲器地址爲R1的字數據讀入寄存器R0
LDR R0,[R1,R2] // 將存儲器地址爲R1+R2的字數據讀入寄存器R0
LDR R0,[R1,#8] // 將存儲器地址爲R1+8的字數據讀入寄存器R0
LDR R0,[R1,R2]! // 將存儲器地址爲R1+R2的字數據讀入寄存器R0，並將新地址R1＋R2寫入R1
LDR R0,[R1,#8]! // 將存儲器地址爲R1+8的字數據讀入寄存器R0，並將新地址R1＋8寫入R1
LDR R0,[R1],R2 // 將存儲器地址爲R1的字數據讀入寄存器R0，並將新地址R1＋R2寫入R1
LDR R0,[R1,R2,LSL#2]! // 將存儲器地址爲R1＋R2×4的字數據讀入寄存器R0，並將新地址R1＋R2×4寫入R1
LDR R0,[R1],R2,LSL#2 // 將存儲器地址爲R1的字數據讀入寄存器R0，並將新地址R1＋R2×4寫入R1
STR R0,[R1],#8 // 將R0中的字數據寫入以R1爲地址的存儲器中，並將新地址R1＋8寫入R1
STR R0,[R1,#8] // 將R0中的字數據寫入以R1＋8爲地址的存儲器中
堆棧平衡
函數執行前後，函數裏面的堆棧要保持不變，如果變了，也就是用了push、sub sp ,0x10，那麼一定要在函數ret之前，恢復對棧原來的樣子 (pop, add sp, 0x10). 如果堆棧不平衡，程序就會崩潰
arm64
rax，rbx，rcx，rdx，esi，edi，rbp，rsp，r8，r9，r10，r11，r12，r13，r14，r15。其中：
rax 作爲函數返回值使用。
rsp 棧指針寄存器，指向棧頂
rdi，rsi，rdx，rcx，r8，r9 用作函數參數，依次對應第1參數，第2參數。。。
rbx，rbp，r12，r13，14，15 用作數據存儲，調用子函數之前要備份它，以防他被修改
r10，r11 用作數據存儲，使用之前要先保存原值
main: # @main
push rbp //壓棧
mov rbp, rsp
sub rsp, 48 //分配棧空間 rsp棧頂指針
mov dword ptr [rbp - 4], edi
mov qword ptr [rbp - 16], rsi
mov eax, dword ptr [.L__const.main.s]
mov dword ptr [rbp - 24], eax
movabs rax, offset .L.str
mov qword ptr [rbp - 40], rax
mov edi, 20
call malloc
mov qword ptr [rbp - 32], rax
mov rdi, qword ptr [rbp - 32]
call free
mov qword ptr [rbp - 32], 0
xor eax, eax
add rsp, 48 //堆棧平衡
pop rbp //出站
ret
a:
.long 0 # 0x0
p1:
.quad 0
.L__const.main.s:
.asciz "abc"
.L.str:
.asciz "bilei"
armv7
main:
push {r11, lr}
mov r11, sp
sub sp, sp, #24
str r0, [r11, #-4]
str r1, [r11, #-8]
ldr r0, .LCPI0_0
str r0, [sp, #8]
ldr r0, .LCPI0_1
str r0, [sp]
mov r0, #20
bl malloc
str r0, [sp, #4]
ldr r0, [sp, #4]
bl free
mov r0, #0
str r0, [sp, #4]
mov sp, r11
pop {r11, lr}
bx lr
.LCPI0_0:
.long 6513249 @ 0x636261
.LCPI0_1:
.long .L.str
a:
.long 0 @ 0x0
p1:
.long 0
.L.str:
.asciz "bilei"
armv8
main: // @main
sub sp, sp, #64 // =64
stp x29, x30, [sp, #48] // 16-byte Folded Spill
add x29, sp, #48 // =48
stur w0, [x29, #-4]
stur x1, [x29, #-16]
adrp x8, .L__const.main.s
add x8, x8, :lo12:.L__const.main.s
ldr w9, [x8]
str w9, [sp, #24]
adrp x8, .L.str
add x8, x8, :lo12:.L.str
str x8, [sp, #8]
mov x0, #20
bl malloc
str x0, [sp, #16]
ldr x0, [sp, #16]
bl free
str xzr, [sp, #16]
mov w9, wzr
mov w0, w9
ldp x29, x30, [sp, #48] // 16-byte Folded Reload
add sp, sp, #64 // =64
ret
a:
.word 0 // 0x0
p1:
.xword 0
.L__const.main.s:
.asciz "abc"
.L.str:
.asciz "bilei"
實戰
學習網站:https://godbolt.org/
https://files.cnblogs.com/files/pythonywy/測試so.zip
#include <stdlib.h>
#include <stdio.h>
typedef struct{
int age;
char *name;
int grade;
short fenshu;
}Student;
struct Test{
int num;
char c;
short data;
};
int sum(int a, int b){
return a+b;
}
void sum1(int *a){
a[1] = 2;
}
int main(int argc, const char * argv[]) {
// char *result_func = func();
for(int i=0;i<100;i++){
printf("%s\n",func3());
}
for(int i=0;i<100;i++){
printf("%s\n",func1());
}
for(int i=0;i<100;i++){
printf("%d\n",func2());
}
int a=2;
int array[8] = {1,2,3,4,5,6,7,8};
int array1[8] = {1,2,3,4,5,6,7,8};
int array2[8] = {1,2,3,4,5,6,7,8};
int array3[][3] = {{1,2,3},{4,5,6},{7,8,9}};
int *p_array[8] = {array,array1,array2};
int (*q_array)[3] = &array3[0];
int (*fun_p)(int a, int b);//函數指針
fun_p = sum;//將函數的首地址賦值給fun_p
int size1 =(int) sizeof(Test);
Student *stu = new Student();//申請內存空間，也可以mac
int size =(int) sizeof(Student);
stu->name = "bilei";
stu->age = 8;
stu->grade = 2;
int a = (*fun_p)(1,2);
char *q = (char*)malloc(8);
q = (stu->name);
int aa = *(q +1);
a = stu->name[1];
if(a>0){
a = sum(a, stu->age);
}
switch (a){
case 1:
a = a<<1;
case 2:
a = a<<2;
case 3:
a = a<<3;
case 4:
a = a<<4;
default:
a = a;
}
stu->grade = a;
short b = 2;
long l = 3;
char c = 'v';
char *p = "hello,world";
char q1 = *(p+1);
char s = *p+1;
sum1(array);
}