#mark- 01-指針和數(shù)組
//問題:指針類型的用途是什么?
答:
第一個用途, 取值的時候, 會根據(jù)指針類型所占用的字節(jié)去取出對應字節(jié)的數(shù)據(jù)
第二個用途, 用于做加法運算, 指針+1, 其實是加上指針類型所占用的長度 , 如果當前指針類型是int, 那么+1本質上是加上4個字節(jié)
#mark- 02-指針和字符串
//問題1.通過數(shù)組保存字符串和通過指針保存字符串的區(qū)別?
答:
1)如果通過數(shù)組來保存字符串, 那么字符串是一個變量 str? 可以修改
如果通過指針來保存字符串, 那么字符串是一個常量 str2 不能修該
2)數(shù)組保存的字符串存儲在內存的棧中, 而通過指針保存的字符串存儲在常量區(qū)
//問題2:字符串存儲在棧中和存儲在常量區(qū)中有什么區(qū)別?
答:
存儲在棧中的變量有一個特點, 當作用域結束系統(tǒng)會自動釋放該變量
存儲在常量區(qū)中的值有一個特點, 不會被釋放, 而且多個相同的值對應的地址相同
char str3[] = "lnj";
printf("str = %p\n", str);
printf("str3 = %p\n", str3);
char *str4 = "lmj";
printf("str2 = %p\n", str2);
printf("str4 = %p\n", str4);
//問題3:保存字符串的方式有哪些?
答:
char str[] = "lnj";
存儲的位置: 棧
特點: 相同的字符串會重復的分配存儲空間
字符串可以修改
char *str = "lnj"
存儲的位置: 常量區(qū)
特點: 相同的字符串不會重復的分配存儲空間
字符串不可以修改
#mark- 03-指針和字符串注意點
//問題:指針保存字符串有什么注意點?
答:
//1.指針沒有被初始化不能隨便使用, 野指針
int *p;
printf("*p = %i\n", *p);
//2.scanf不能用指針接收字符串,只能用數(shù)組接收(指針指向的字符串是一個常量,不能被修改)
char str[10];
scanf("%s", str);
printf("str = %s\n", str);
指針沒有初始化, 是野指針
char *str;
scanf("%s", str);
printf("str = %s\n", str);
//注意: 用指針來保存字符串不可以被修改
// 指針沒有初始化不能隨便使用
#mark- 04-指針數(shù)組
//問題:指針數(shù)組的本質是什么?
答:指針數(shù)組中保存的每一個元素都是指針
//也叫字符串數(shù)組
// 定義數(shù)組的格式: 元素類型 數(shù)組名稱[元素的個數(shù)]
char *names[4] =
{
"lnj",
"lmj",
"jjj",
"lk"
};
for (int i = 0; i < 4; i++) {
printf("names[%i] = %s\n", i , names[i]);
}
#mark- 05-指針變量的作用
//問題:數(shù)據(jù)類型可以做哪3件事?
//數(shù)組作為函數(shù)參數(shù),專業(yè)做法用指針接收
1.可以用來定義變量
2.可以用來作為形參的類型
3.作為返回值
//問題2:指針保存字符串和數(shù)組字符串,作為函數(shù)返回值有什么區(qū)別?
char *name = demo();
printf("name = %s\n", name);
char *name2 = demo2();
printf("name2 = %s\n", name2);
char *demo2()
{
char name[]= "lnj";
return name;
}
char *demo()
{
char *name = "lnj";
return name;
}
#mark- 06-指針綜合練習
//問題:這一節(jié)使用了哪些知識點?
答:
// 自己可以嘗試實現(xiàn)strlen函數(shù)
函數(shù)運用的知識:
1.任何數(shù)值都有真假性
2.++ 在前,在后區(qū)別
3.指針+1, 其實是加上指針類型所占用的長度
4.循環(huán)語句省略大括號,只會執(zhí)行最近的一行語句
char *name = "lnj";
int size =myStrlen3(name);
printf("size = %i\n", size);
int myStrlen3(char *str)
{
int count = 0;
// \0 ascii 0 // 0代表假 1真
while (*str++)count++;
return count;
}
#mark- 07-指向函數(shù)的指針基本概念
//問題:指向函數(shù)的指針的格式?指向函數(shù)的指針有幾種類型?
//1.指向函數(shù)的指針的定義格式
void (*funtionP) ();
*? ? : 代表是一個指針
funtionP? ? : 代表指針變量的名稱, 區(qū)分
(*funtionP) : 代表將來指向一個函數(shù)
void : 代表將來指向的函數(shù)沒有返回值
()? : 代表將來指向的函數(shù)沒有參數(shù)
//2.指向函數(shù)的指針第一種方式
void (*funtionP) ();
funtionP = test; // 注意: 千萬不能寫成test()
test(); // 0x100000f00();
(*funtionP)(); // 0x100000f00()
// test == funtionP
funtionP();
//3.四種函數(shù)類型 的指針
//沒有返回值沒有參數(shù)
void test()
{
printf("哥被執(zhí)行了\n");
}
//有返回值沒有參數(shù)
int getAge()
{
return 30;
}
//沒有返回值有參數(shù)
void sum(int v1, int v2)
{
int res = v1 +? v2;
printf("res = %i\n", res);
}
//有返回值有參數(shù)
int sum2(int v1 , int v2)
{
int res = v1 + v2;
return? res;
}
int main(int argc, const char * argv[]) {
printf("test = %p\n", test);
//1).指向 沒有返回值沒有參數(shù)的指針
void (*funtionP) ();
funtionP = test; // 注意: 千萬不能寫成test()
test(); // 0x100000f00();
(*funtionP)(); // 0x100000f00()
// test == funtionP
funtionP();
//2).指向 有返回值沒有參數(shù)的指針
int (*ageP)();
ageP = getAge;
printf("age = %i\n", ageP());
//3).指向 沒有返回值有參數(shù)的指針
//? ? void (*sumP)(int v1, int v2);
void (*sumP)(int, int); //形參名可以省略
sumP = sum;
sumP(10, 20);
//4).指向 有返回值有參數(shù)的指針
int (*sumP2)(int , int);
sumP2 = sum2;
printf("sum = %i\n", sumP2(10, 20));
}
#mark- 08-指向函數(shù)的指針應用場景
//問題:指向函數(shù)的指針應用場景是什么?
答:通過指向函數(shù)的指針將函數(shù)作為函數(shù)的參數(shù)傳遞
// 定義一個方法, 給你兩個數(shù), 用戶要求你做加法你就做加法, 用戶要求你做減法, 那你就做減法
int sum(int v1, int v2)
{
return v1 + v2;
}
int minus(int v1, int v2)
{
return v1 - v2;
}
// 以后我們只需要給demo函數(shù)傳遞對應的指針, 那么函數(shù)內部就可以調用不同的函數(shù)
int demo3(int v1, int v2, int (*p)(int, int))
{
return p(v1, v2);
}
int main(int argc, const char * argv[]) {
printf("mins = %i\n", demo3(20, 10, minus));
printf("sum = %i\n", demo3(20, 10, sum));
return 0;
}
#mark- 09-指向函數(shù)的指針練習
void ts(char *temp, void (*funtionP)(char *))
{
// 1.先將第一個字母轉換為大寫
upperCase(temp);
// temp == &str[0]
while (*temp != '\0') { // h e l l o 空格 w
// 2.1取出當前的字符, 判斷是否等于 空格, 如果等于空格就需要將下一個字符轉換為大寫
if ((*temp) == ' ') {
// 2.2將下一個字符轉換為大寫
funtionP(++temp);
}else
{
temp++; // temp == &str[7];
}
}
}
//小寫轉換為大寫
void upperCase(char *p)
{
// 1.判斷是否是小寫字母
if (*p >= 'a' && *p <= 'z') {
// 2.將小寫字母轉換為大寫字母
*p = *p - ('a'? - 'A'); // 32 小寫的ascii大于大寫
}
}
#mark- 10-結構體基本概念
//問題:如何定義結構體變量?結構體的格式?如何給結構體的屬性賦值?
答:
數(shù)組: 是用于保存一組相同類型的數(shù)據(jù)
結構體: 是用于保存一組不同類型的數(shù)據(jù)
//1.定義一個結構體變量
1).定義結構體類型
2).根據(jù)結構體類型, 定義結構體變量
定義結構體類型的格式:
struct 結構體類型名稱
{
屬性;
};
//2.可以使用 結構體變量名稱.屬性的方式給結構體變量賦值
// 1.定義結構體類型
struct Person
{
char *name;
int age;
double height;
};
// 2.定義結構體變量
struct Person p;
// 注意: 數(shù)組不能先定義再進行一次性的初始化, 所以結構體中字符串用指針接收
p.name = "lnj";
p.age = 30;
p.height = 1.75;
#mark- 11-結構體初始化
//問題:結構體初始化的幾種方式?如何從結構體中獲取數(shù)據(jù)?
答:
注意和數(shù)組的對比學習
struct Dog
{
char *name;
int age;
double height;
};
// 1.定義的同時初始化
struct Dog sd = {"wc", 13, 5.0};
// 2.先定義再初始化(逐個初始化)
struct Dog sd1;
sd1.name = "ww";
sd1.age = 5;
sd1.height = 10.9;
// 3.先定義再初始化(一次性初始化)
struct Dog sd2;
// 特別注意: 結構體和數(shù)組有一點區(qū)別, 數(shù)組不能先定義再進行一次性的初始化, 而結構體可以
// 只不過需要明確的告訴系統(tǒng){}中是一個結構體
sd2 = (struct Dog){"xq", 8, 8.8}; // 數(shù)組? 結構體?
// 4.指定將數(shù)據(jù)賦值給指定的屬性
struct Dog sd3 = {.height = 1.77, .name = "ww", .age = 33};
printf("name = %s, age = %i, height = %lf\n", sd3.name, sd3.age, sd3.height);
#mark- 12-結構體內存分配
//問題:結構體變量是如何分配內存空間的?
答:
1.定義結構體類型并不會分配存儲空間
2.只有定義結構體變量才會真正的分配存儲空間
3.結構體第0個屬性的地址就是結構體的地址
4.和數(shù)組一樣, 結構體內存尋址從大到小, 存儲數(shù)組是從小到大(先存儲第0個屬性, 再一次存儲其它屬性)
//問題2.結構體如何開辟存儲空間?
答:
結構體分配存儲空間本質上并不是將所有屬性占用的存儲空間的總和加在一起后再分配,
而是會獲取結構體類型中占用內存最大的屬性的大小, 然后取該大小的倍數(shù)
特例:
如果剩余的存儲空間"不夠"存儲將要存儲的數(shù)據(jù), 那么就會重新開辟8個字節(jié)的存儲空間, 并且將需要存儲的數(shù)據(jù)放到新開辟的存儲空間中
如果剩余的存儲空間"夠"存儲將要存儲的數(shù)據(jù), 那么就不會開辟了
#mark- 13-結構體類型定義方式
//問題:結構體類型有幾種定義方式?
答:
// 1.先定義結構體類型, 再定義結構體變量
struct Person
{
int age;
char *name;
double height;
};
struct Person sp;
// 2.定義結構體類型的同時定義結構體變量
struct Person
{
int age;
char *name;
double height;
} sp;
// 數(shù)據(jù)類型 變量名稱
sp.age = 30;
printf("age = %i\n", sp.age);
struct Person? sp1;
sp1.name = "lnj";
printf("name = %s\n", sp1.name);
// 3.定義結構體類型的同時定義結構體變量, 并且省略結構體名稱
// 如果在定義結構體類型的同時定義結構體變量, 那么可以省略結構體類型名稱
// 弊端: 由于結構體類型沒有名稱, 所以以后就不能使用該結構體類型
// 優(yōu)點: 如果結構體類型只需要使用一次, 那么可以使用該方式
struct
{
int age;
char *name;
double height;
} sp;
sp.age = 55;
printf("age = %i\n", sp.age);
#mark- 14-結構體類型作用域
//問題:結構體類型的作用域的注意點有哪些?
答:
1.在不同的作用域中可以有同名的局部變量, 如果訪問采用就近原則
2.在不同的作用域中可以定義同名的結構體類型, 如果使用同名的結構體類型定義結構體變量, 采用就近原則
3.如果將結構體類型寫在函數(shù)或者代碼塊外面, 那么結構體類型的作用域和全局變量一樣, 從定義的那一行開始一直直到文件末尾
4.相同作用域不能有同名的結構體類型
#mark- 15-指向結構體的指針
//問題1.如何定義指向結構體變量的指針?
答:
1.拷貝結構體類型 和 結構體變量名稱
2.在類型和名稱中間加上一顆心
struct Person
{
int age;
char *name;
double height;
};
struct Person sp = {30, "lnj", 1.75};
sp.name = "lnj";
sp.age = 30;
sp.height = 1.75;
// 定義了一個指向結構體的指針
// *sip == sp
struct Person *sip;
sip = &sp;
//問題2.當指針指向結構體之后如何利用指針訪問結構體?
答:
結構體變量名稱.屬性;
(*結構體指針變量名稱).屬性;
結構體指針變量名稱->屬性;
#mark- 16-結構體數(shù)組
//問題:結構體數(shù)組格式是什么?如何獲取結構體數(shù)組中的屬性?
答:
// 元素類型 數(shù)組名稱[元素個數(shù)];
struct Bumen bumens[3] =
{
{"iOS", 20, 100.0}, // 0
{"Andoird", 10, 99.0},
{"php", 500, 88.0}
};
//? ? bumens[0] == ios
bumens[0].name = "iOSv587";
bumens[0].count = 99;
bumens[0].kpi = 100.0;
printf("name = %s, count = %i, kpi = %lf\n", bumens[0].name, bumens[0].count, bumens[0].kpi);
#mark- 17-結構體嵌套
//問題:結構體如何進行嵌套?如何給結構體中嵌套的結構體賦值或者訪問?
答:
//賦值
如果結構體類型中的屬性又是一個結構體, 那么賦值時候通過{}賦值
//訪問
如果結構體的屬性又是一個結構體, 那么可以通過連續(xù).的方式, 訪問結構體屬性中的屬性
#mark- 18-結構體和函數(shù)
//問題:結構體作為函數(shù)的參數(shù)如何傳遞?結構體之間賦值是如果傳遞的?
答:
1.將結構體的屬性傳遞給函數(shù), 在函數(shù)中修改形參不會影響到實參
2.將結構體名稱作為參數(shù)傳遞, 在函數(shù)中修改形參不會影響到實參
結構體之間賦值是值傳遞, 系統(tǒng)會將A結構體的值 拷貝一份到 B結構體中
#mark- 19-枚舉基本概念
//問題:什么是枚舉類型?枚舉類型的格式?定義枚舉的規(guī)范有哪些?
答:
//1.枚舉就是專門用于表示幾種固定類型的取值
枚舉的本質就是基本數(shù)據(jù)類型, 就是整形
//2.枚舉類型定義的格式
enum 枚舉類型名稱
{
取值,
};
//3.通過枚舉類型定義枚舉變量
定義枚舉變量和定義結構體變量一樣, 直接將數(shù)據(jù)類型拷貝過來, 空格之后寫上變量名稱即可
//4.注意點:
由于枚舉類型的本質是整型, 所以枚舉類型除了可以接收枚舉的固定的取值以外, 還可以接收其它整型的值
也就是枚舉類型的變量可以當做int類型的變量來使用
//5.定義枚舉類型的規(guī)范
枚舉類型的取值一般以k開頭 ,后面跟上枚舉類型的名稱 , 跟上當前取值的含義
和結構體一樣, 枚舉類型的名稱首字母大寫
