天天看點
傳回

c基礎-指針、函數與預處理器指針、函數、預處理器

指針、函數、預處理器

文章目錄

  • 指針、函數、預處理器
    • 1、指針
        • 解引用
        • 指針運算
        • 數組和指針
        • const char *, char const *, char * const，char const * const
        • 多級指針
          • 多級指針的意義
    • 2、函數
        • 函數的位置
        • 函數參數
          • 傳值調用
          • 引用調用
        • 可變參數
        • 函數指針
    • 3、預處理器
        • 常用預處理器
        • 宏
    • 作業:手寫sprintf

1、指針

指針是一個變量，其值為位址。

聲明指針或者不再使用後都要将其置為0 (NULL)

野指針 未初始化的指針

懸空指針 指針最初指向的記憶體已經被釋放了的一種指針

int *a; 正規
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);

指針多少個位元組？指向位址，存放的是位址

位址在 32位中指針占用4位元組 64為8

//32位：
sizeof(p) == 4;
//64位:
sizeof(p) == 8;

解引用

解析并傳回記憶體位址中儲存的值 
int i = 10;
int *p = &i;
//解引用  
//p指向一個記憶體位址，使用*解出這個位址的值 即為 10
int pv = *p;
//修改位址的值,則i值也變成100
//為解引用的結果指派也就是為指針所指的記憶體指派
*p = 100;

指針運算 

//對指針 進行算數運算
//數組是一塊連續記憶體 分别儲存 11-55
//*p1 指向第一個資料 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]

}
指針指向位址，指針運算實際上就是移動指針指向的位址位置,移動的位數取決于指針類型（int就是32位）
c基礎-指針、函數與預處理器指針、函數、預處理器

數組和指針

在c語言中，指針和數組名都表示位址

1、數組是一塊記憶體連續的資料。

2、指針是一個指向記憶體空間的變量

int i1[] = {11,22,33,44,55};
//直接輸出數組名會得到數組首元素的位址
printf("%#x\n",i1);
//解引用
printf("%d\n",*i1);
//将數組名指派給一個指針，這時候指針指向數組首元素位址
int *p1 = i1;

//數組指針
//二維數組類型是 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的數組 是以 +1 移動了12位
array1 + 1 
//2、獲得{44,55,66}數組  (*(array1 + 1))[1] = 55
(*(array1 + 1) 
//3、對數組執行 +/- 相當于隐式的轉為指針
//獲得 55 的位址 再解位址
*(array1 + 1) + 1
 
 
//指針數組
int *array2[2];
array2[0] = &i;
array2[1] = &j;

const char *, char const *, char * const，char const * const

const ：常量 = final 
//從右往左讀
//P是一個指針 指向 const char類型
char str[] = "hello";
const char *p = str;
str[0] = 'c'; //正确
p[0] = 'c';   //錯誤 不能通過指針修改 const char

//可以修改指針指向的資料 
//意思就是 p 原來 指向david,
//不能修改david愛去天之道的屬性，
//但是可以讓p指向lance，lance不去天之道的。
p = "12345";

//性質和 const char * 一樣
char const *p1;

//p2是一個const指針 指向char類型資料
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);
多級指針的意義
見函數部分的引用傳值

2、函數

C中的函數與java沒有差別。都是一組一起執行一個任務的語句，也都由 函數頭與函數體構成

函數的位置

聲明在使用之前

函數參數

傳值調用

​ 把參數的值複制給函數的形式參數。修改形參不會影響實參

引用調用

​ 形參為指向實參位址的指針，可以通過指針修改實參。

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

可變參數

與Java一樣，C當中也有可變參數 
#include <stdarg.h>
int add(int num, ...)
{
	va_list valist;
	int sum = 0;
	// 初始化  valist指向第一個可變參數 (...)
	va_start(valist, num);
	for (size_t i = 0; i < num; i++)
	{
		//通路所有賦給 valist 的參數
		int j = va_arg(valist, int);
		printf("%d\n", j);
		sum += j;
	}
	//清理為 valist 記憶體
	va_end(valist);
	return sum;
}

函數指針

函數指針是指向函數的指針變量 
void println(char *buffer) {
	printf("%s\n", buffer);
}
//接受一個函數作為參數
void say(void(*p)(char*), char *buffer) {
	p(buffer);
}
void(*p)(char*) = println;
p("hello");
//傳遞參數
say(println, "hello");

//typedef 建立别名 由編譯器執行解釋
//typedef unsigned char u_char;
typedef void(*Fun)(char *);
Fun fun = println;
fun("hello");
say(fun, "hello");

//類似java的回調函數
typedef void(*Callback)(int);

void test(Callback callback) {
	callback("成功");
	callback("失敗");
}
void callback(char *msg) {
	printf("%s\n", msg);
}

test(callback);

3、預處理器

預處理器不是編譯器，但是它是編譯過程中一個單獨的步驟。

預處理器是一個文本替換工具

所有的預處理器指令都是以井号（#）開頭

常用預處理器

預處理器 說明
#include 導入頭檔案
#if if
#elif else if
#else else
#endif 結束 if
#define 宏定義
#ifdef 如果定義了宏
#ifndef 如果未定義宏
#undef 取消宏定義

宏

預處理器是一個文本替換工具

宏就是文本替換 
//宏一般使用大寫區分
//宏變量
//在代碼中使用 A 就會被替換為1
#define A 1
//宏函數
#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));

宏函數

​ 優點：

​ 文本替換，每個使用到的地方都會替換為宏定義。

​ 不會造成函數調用的開銷（開辟棧空間，記錄傳回位址，将形參壓棧，從函數傳回還要釋放堆

​ 棧。）

​ 缺點：

​ 生成的目标檔案大，不會執行代碼檢查

内聯函數

​ 和宏函數工作模式相似，但是兩個不同的概念，首先是函數，那麼就會有類型檢查同時也可以debug

在編譯時候将内聯函數插入。

不能包含複雜的控制語句，while、switch，并且内聯函數本身不能直接調用自身。

如果内聯函數的函數體過大，編譯器會自動的把這個内聯函數變成普通函數。

作業:手寫sprintf

根據可變參數、指針運算等知識自己實作 sprintf 函數（隻實作 %d 就行）！

ndk基礎 ndk c++ android
上一篇: C語言基礎知識總結（一）
下一篇: 01 C語言基礎 ，指針基礎

繼續閱讀