指針、函數(shù)、預(yù)處理器
[TOC]
1、指針
指針是一個變量，其值為地址。
聲明指針或者不再使用后都要將其置為0 (NULL)
野指針 未初始化的指針
懸空指針 指針最初指向的內(nèi)存已經(jīng)被釋放了的一種指針
int *a; //正規(guī)
int* a;
int * a;
//因為 其他寫法看起來有歧義
int* a,b;
使用：
//聲明一個整型變量
int i = 10;
//將i的地址使用取地址符給p指針
int *p = &I;
//輸出 0xffff 16進制地址
printf("%#x\n", &i);
printf("%#x\n", &p);
指針多少個字節(jié)？指向地址，存放的是地址
地址在 32位中指針占用4字節(jié) 64為8
//32位：
sizeof(p) == 4;
//64位:
sizeof(p) == 8;
解引用
解析并返回內(nèi)存地址中保存的值
int i = 10;
int *p = &I;
//解引用
//p指向一個內(nèi)存地址，使用*解出這個地址的值 即為 10
int pv = *p;
//修改地址的值,則i值也變成100
//為解引用的結(jié)果賦值也就是為指針所指的內(nèi)存賦值
*p = 100;
指針運算
//對指針 進行算數(shù)運算
//數(shù)組是一塊連續(xù)內(nèi)存 分別保存 11-55
//*p1 指向第一個數(shù)據(jù) 11，移動指針就指向第二個了
int i1[] = {11,22,33,44,55};
int *p1 = i1;
for (size_t i = 0; i < 5; I++)
{
//自增++ 運算符比 解引用* 高,但++在后為先用后加
//如果++在前則輸出 22-55+xx
printf("%d\n", *p1++);
//p1[0] == *(p1+1) == s[1]
}
指針指向地址，指針運算實際上就是移動指針指向的地址位置,移動的位數(shù)取決于指針類型（int就是32位）
數(shù)組和指針
在c語言中，指針和數(shù)組名都表示地址
1、數(shù)組是一塊內(nèi)存連續(xù)的數(shù)據(jù)。
2、指針是一個指向內(nèi)存空間的變量
int *p[4] 由于[]比* 優(yōu)先級高，因此p先于[4]結(jié)合，形成p[4]形式，這顯然是數(shù)組形式，它有4個元素。然后再與p前面的“ * ”結(jié)合，“ * ”表示此數(shù)組是指針類型的，每個數(shù)組元素(相當于一個指針變量)都可以指向一個整形變量。
注意：不要寫成“int(*p)[4];”，這是指向一維數(shù)組的指針變量。
int i1[] = {11,22,33,44,55};
//直接輸出數(shù)組名會得到數(shù)組首元素的地址
printf("%#x\n",i1);
//解引用
printf("%d\n",*i1);
//將數(shù)組名賦值給一個指針，這時候指針指向數(shù)組首元素地址
int *p1 = i1;
//數(shù)組指針
//二維數(shù)組類型是 int (*p)[x]
int array[2][3] = { {11,22,33},{44,55,66} };
//也可以 int array[2][3] = { 11,22,33 ,44,55,66 };
//array1 就是一個 int[3] 類型的指針
int (*array1)[3] = array;
//怎么取 55 ？
//通過下標
array[1][1] == array1[1][1]
//通過解引用
int i = *(*(array1 + 1) + 1);
//拆分
//1、 指針偏移 因為array1的類型是3個int的數(shù)組 所以 +1 移動了12位
array1 + 1
//2、獲得{44,55,66}數(shù)組 (*(array1 + 1))[1] = 55
(*(array1 + 1)
//3、對數(shù)組執(zhí)行 +/- 相當于隱式的轉(zhuǎn)為指針
//獲得 55 的地址 再解地址
*(array1 + 1) + 1
//指針數(shù)組
int *array2[2];
array2[0] = &I;
array2[1] = &j;
const char *, char const *, char * const，char const * const
const ：常量 = final
- 常量指針(指向常量的指針變量)
const 類型名 * 指針變量名
int a = 12;
int b = 15;
//注意int const *p與int const *p效果相同。
const int * p = &a;//定義了p為指向整型變量a的const指針變量
p = &b;//正確
*p = b;//非法
- 指針常量(常指針)
類型名 * const 指針變量名
int * const p = &a;
p = &b;//非法
*p = b;//正確
- 指向常量的指針常量
const 基本類型名 * const 指針變量名
const int * const p = &a;
p = &b;//非法
*p = b;//非法
總結(jié)：
- const在前:表示const修飾的為所申請的類型。常量指針
- const在后:表示const修飾的為指針。指針常量
- 前*后均有:表示const同時修改類型和指針。指向常量的指針常量
(指針)和const(常量)誰在前先讀誰：*象征著地址，const象征著內(nèi)容：誰在前面誰就不允許改版。
//從右往左讀
//P是一個指針 指向 const char類型
char str[] = "hello";
const char *p = str;
str[0] = 'c'; //正確
p[0] = 'c'; //錯誤 不能通過指針修改 const char
//可以修改指針指向的數(shù)據(jù)
//意思就是 p 原來 指向張三,
//不能修改張三的屬性，
//但是可以讓p指向李四。
p = "12345";
//性質(zhì)和 const char * 一樣
char const *p1;
//p2是一個const指針 指向char類型數(shù)據(jù)
char * const p2 = str;
p2[0] = 'd'; //正確
p2 = "12345"; //錯誤
//p3是一個const的指針變量 意味著不能修改它的指向
//同時指向一個 const char 類型 意味著不能修改它指向的字符
//集合了 const char * 與 char * const
char const* const p3 = str;
多級指針
指向指針的指針
一個指針包含一個變量的地址。當我們定義一個指向指針的指針時，第一個指針包含了第二個指針的地址，第二個指針指向包含實際值的位置。
int a = 10;
int *i = &a;
int **j = &I;
// *j 解出 i
printf("%d\n", **j);
多級指針的意義
見函數(shù)部分的引用傳值
2、函數(shù)
C中的函數(shù)與java沒有區(qū)別。都是一組一起執(zhí)行一個任務(wù)的語句，也都由 函數(shù)頭與函數(shù)體構(gòu)成
函數(shù)的位置
聲明在使用之前
函數(shù)參數(shù)
傳值調(diào)用
? 把參數(shù)的值復制給函數(shù)的形式參數(shù)。修改形參不會影響實參
引用調(diào)用
? 形參為指向?qū)崊⒌刂返闹羔槪梢酝ㄟ^指針修改實參。
void change1(int i) {
i = 10;
}
void change2(int *i) {
*i = 10;
}
int i = 1;
change1(i);
printf("%d\n",i); //i == 1
change2(&i);
printf("%d\n",i); //i == 10
可變參數(shù)
與Java一樣，C當中也有可變參數(shù)
#include <stdarg.h>
int add(int num, ...)
{
//表示...的參數(shù)列表
va_list valist;
int sum = 0;
// 初始化 valist指向第一個可變參數(shù) (...)
va_start(valist, num);
for (size_t i = 0; i < num; I++)
{
//訪問所有賦給 valist 的參數(shù)
int j = va_arg(valist, int);
printf("%d\n", j);
sum += j;
}
//清理為 valist 內(nèi)存
va_end(valist);
return sum;
}
函數(shù)指針
函數(shù)指針是指向函數(shù)的指針變量
void println(char *buffer) {
printf("%s\n", buffer);
}
/**
* void(*p)(char*)函數(shù)
* void 返回值
* (*p) p變量用來表示這個函數(shù)
* (char*) 函數(shù)的參數(shù)列表
*/
//接受一個函數(shù)作為參數(shù)
void say(void(*p)(char*), char *buffer) {
p(buffer);
}
void(*p)(char*) = println;
p("hello");
//傳遞參數(shù)
say(println, "hello");
//typedef 創(chuàng)建別名 由編譯器執(zhí)行解釋
//typedef unsigned char u_char;
typedef void(*Fun)(char *);
Fun fun = println;
fun("hello");
say(fun, "hello");
//類似java的回調(diào)函數(shù)
typedef void(*Callback)(int);
void test(Callback callback) {
callback("成功");
callback("失敗");
}
void callback(char *msg) {
printf("%s\n", msg);
}
test(callback);
3、預(yù)處理器
預(yù)處理器不是編譯器，但是它是編譯過程中一個單獨的步驟。
預(yù)處理器是一個文本替換工具
所有的預(yù)處理器命令都是以井號（#）開頭（凡是以“#”開頭的均為預(yù)處理命令）
常用預(yù)處理器
| 預(yù)處理器 | 說明 |
|---|---|
| #include | 導入頭文件 |
| #if | if |
| #elif | else if |
| #else | else |
| #endif | 結(jié)束 if |
| #define | 宏定義 |
| #ifdef | 如果定義了宏 |
| #ifndef | 如果未定義宏 |
| #undef | 取消宏定義 |
宏
預(yù)處理器是一個文本替換工具
宏就是文本替換
//宏一般使用大寫區(qū)分
//宏變量
//在代碼中使用 A 就會被替換為1
#define A 1
//宏函數(shù)
#defind test(i) i > 10 ? 1: 0
//其他技巧
// # 連接符 連接兩個符號組成新符號
#define DN_INT(arg) int dn_ ## arg
DN_INT(i) = 10;
dn_i = 100;
// \ 換行符
#define PRINT_I(arg) if(arg) { \
printf("%d\n",arg); \
}
PRINT_I(dn_i);
//可變宏
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,"NDK", __VA_ARGS__);
//陷阱
#define MULTI(x,y) x*y
//獲得 4
printf("%d\n", MULTI(2, 2));
//獲得 1+1*2 = 3
printf("%d\n", MULTI(1+1, 2));
宏函數(shù)
? 優(yōu)點：
? 文本替換，每個使用到的地方都會替換為宏定義。
? 不會造成函數(shù)調(diào)用的開銷（開辟?？臻g，記錄返回地址，將形參壓棧，從函數(shù)返回還要釋放堆棧。）
? 缺點：
? 生成的目標文件大，不會執(zhí)行代碼檢查
內(nèi)聯(lián)函數(shù)
? 和宏函數(shù)工作模式相似，但是兩個不同的概念，首先是函數(shù)，那么就會有類型檢查同時也可以debug
在編譯時候?qū)?nèi)聯(lián)函數(shù)插入。不能包含復雜的控制語句，while、switch，并且內(nèi)聯(lián)函數(shù)本身不能直接調(diào)用自身。
如果內(nèi)聯(lián)函數(shù)的函數(shù)體過大，編譯器會自動的把這個內(nèi)聯(lián)函數(shù)變成普通函數(shù)。
