-###———————————————————————–

---

阿發你好第2章

輸出指定寬度的數字

#include <stdio.h>
#include <stdlib.h>
int main(){printf("number is %d\n", 3);printf("number is %d\n", 33);printf("number is %d\n", 333);printf("number is %4d\n", 3);printf("number is %4d\n", 33);printf("number is %4d\n", 333);//表示輸出都是4個自出長度printf("number is %04d\n", 3);printf("number is %04d\n", 33);printf("number is %04d\n", 333);//04d表示不足四位用0補齊system("pause");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include "stdio.h"
int main(){printf("x=%lf\n",1.23424);return 0;}
1
2
3
4
5
6
1
2
3
4
5
6

用變量表示小數
（我使用的IDE是kdevelop F8是編譯 F9是運行）

#include "stdio.h"
int main(){double a=1.123;printf("x=%lf\n",a);return 0;
}
1
2
3
4
5
6
1
2
3
4
5
6

指定小數后的位數

#include "stdio.h"
int main(){double a=1.12334;printf("x=%.2lf\n",a);return 0;}
1
2
3
4
5
6
7
1
2
3
4
5
6
7

輸入一個長整型

#include "stdio.h"
int main(){scanf("%lf",&a);return 0;
}
1
2
3
4
5
1
2
3
4
5

變量的命名規則：必須是字母下劃線數字的組合，可以用字母或者下劃線開頭，但是不能用數字開頭
char 型變量能夠表示-128~127之間的整數2^7=128最高為是符號位。
long ：4字節 占32位，
printf 可以輸出char short int 都可以

無符號類型

unsigned char 表示的范圍0~255 就是i原來2^8-1 就是255
在調用無符號整數用%u來表示
%u 在用scanf的時候，只能用unsigned int 來接收，不能用unsigned char/short

#include "stdio.h"
int main(){unsigned int a=0;scanf("%u\n",&a);return 0;
}
1
2
3
4
5
6
1
2
3
4
5
6

浮點類型

用于小數的類型有兩種：double，float 類型，統稱為浮點型，需要表示高的精度類型應該用double ,當精度要求不高的時候，用float類型

float a= 3.14f//這里數字后面要加一個f
scanf("%f\n",a);
1
2
1
2

單步調試

通常我們總是用F5進行編譯，原來不知道有F7也可以進行生成解決方案，用F10進行單步運行。用F9進行打斷點

第一次調用數組
1
1

#include <iostream>
using namespace std;
int main()
{int data[4] = { 1, 2, 3, 4 };int total=0;for (int i = 0; i <4; ++i){total += data[i];}cout << total<<endl;return 0;system("puase");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
9
10
11
12
13
14

如何描述一下錯誤:
前提條件：當我輸入…….的時候，
預期結果：可以正常編譯
實際結果：不是我預期的效果（或者是無法正常編譯）

對于測試人員：將問題進行復現，只有將問題復現才能解決

指針變量如何看他的地址：

在地址的框寫入p 然后按回車就可以自動把p的地址寫到這個里面

阿發你好 第3章

2016/11/13

十進制、十六進制的表示方法

int a=123;//表示的10進制
int a=0x123；//表示的16進制 將這個16進制的數化成10進制的話 等于3*16^0+2*16^1+1*16^2
1
2
1
2

內存的表示

內存使用在存儲計算機中的二進制數
內存的基本單元是字節，一個字節由8位二進制來表示

一個字節能夠表示的范圍是0~255
每個內存單元都是有地址的，地址表示的范圍;00000000~FFFFFFFF;

int a=10;//10就是一個字面常量，a就是一個變量
1
1

變量與內存

char 型變量：占1個字節
short型變量：占2個字節
int 型變量：占4個字節 4 個字節（4*8=32位 那么最大值：2^33-1）
float 類型占4個字節
double類型占8個字節

//用sizeof（int）可以返回出這個類型所占的字節
#include <iostream>
using namespace std;
int main()
{cout << sizeof(int) << endl;system("pause");
}
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8

然后求一個變量的所占的字節

#include <iostream>
using namespace std;
int main()
{int a = 10;cout << sizeof(a) << endl;system("pause");
}
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8

#include <iostream>
using namespace std;
int main()
{int a = 10;cout << &a<< endl;system("pause");
}
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8

一個字節能夠表示的范圍;00~FF
在C語言中，我們用sizeof來測量一個變量或者類型的大小

const 限制符

如果一個東西，被const修飾之后，那么他就變成一個只讀的常量

字面值常量

int a=1;//1 就是字面值常量，a是一個變量。
1
1

阿發你好 第4章 數組

數組的初始化

 char arr[4]={1,2,3,4};
1
1

注意事項：
1、char arr[3];//可以在定義的時候，不初始化初值
2、char arr[3]={1};//可以只初始化部分初值
3、char arr[]={1,2};//可以只有數值沒有長度`
4、char arr[5]={0};

訪問數組的元素

char arr[3];
arr[0]=1;
1
2
1
2

用sizeof（arr）來訪問數組的長度

char arr[3];
sizeof(arr);
1
2
1
2

多維數組

int arr[1][2];
arr[0][0]=1;
1
2
1
2

對一個二唯數組進行初始化

int a[3][4]=
{
    {11,12,13},
    {21,22,23},
    {31,32,33},
    {41,42,43},
};
1
2
3
4
5
6
7
1
2
3
4
5
6
7

阿發你好第5章 字符與字符串數組

在printf的時候我們用%c來表示字符串

char ch=65;
printf("%c",ch);
1
2
1
2

輸出的結果是A
字符常量

char ch='a';
printf("%d",ch);
1
2
1
2

字符數組

1、一般的初始化方法

char str[3]={'i','l','\0'};
1
1

2、特殊的初始化方法

char str[3]="il";//最后默認添加了/0來表示數組的終止
1
1

輸出字符串
用printf向程序輸出字符串的話，使用格式符%s

char str[2]="I";
printf("%s\n",str);
1
2
1
2

可以使用gets來獲取一個字符串

char burf[2];
gets (burf);gets()的括號里面是數組的名字
printf("%s/n",burf);
1
2
3
1
2
3

在編寫字符串的時候一定要有/0來便是終止。

char str[]={'I',0};
printf("%s",str);
1
2
1
2

在輸出的時候，碰到0就截止
轉義字符
1、\n 換行
2、\用于輸出目錄
3、\t輸出制表符
4、輸出引號printf(“\”asdf”\”);

---

阿發你好第6章 表達式與操作符

算數表達式
賦值表達式
關系表達式
條件表達式

expr1?expr2:expr3;
如果條件expr1為真的時候就執行expr2,否則執行expr3
這個是一個表達式
1
2
3
1
2
3

舉個例子：

printf("%c\n",score>60？'T':'F');
1
1

我們都是用這條語句來簡化計算的
邏輯表達式
！表示非 && 用來表示與 || 用來表示 或

逗號表達式

expr1,expr2,expr3
1
1

是從逗號分開的一組表示式，從左到右依次計算，最后一個表達式為整個表示式的值

int nnn=(1,2,3);//賦值的最后結果是nnn=3
1
1

自增自減運算符

阿發你好第7章 語句

if語句

if (expr)statement1
else (expr)staement2
1
2
3
4
1
2
3
4

switch語句

switch(expr)
{
case option_1:  break;
case option_2:  break;
case option_3:  break;
case option_4:  break;
}
1
2
3
4
5
6
7
1
2
3
4
5
6
7

switch 語句的注意事項：
1、switch和case的選項必須都是整型
case的選項的值必須常量

for語句

for (expr1;expr2;expr3){statement;}
1
2
1
2

在for語句中，如果存在break語句，可以直接跳出for循環
continue語句如果存在for語句大括號內，
當continue語句被執行的時候，表示結束本次循環，直接進入下一次循環

---

while語句

while語句也用于是實現循環，他的基本表達形式：

while (expr)//當expr為1的時候，進入循環體statement
1
2
1
2

t

//將編寫的條件內置
int main(){int i=0;while(1){if(i>100)break;//當i=101的時候，直接跳出循環i++;
}
}
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8

int day=2;
switch(day)
{
case 1: printf("1");
break;//如果沒有break的話，程序會從匹配的入口依次往下執行
case 2:printf("2");
break;
default: printf("3");
break;
}
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10

---

do while 語句

do
{
statement
}while(expr1)
1
2
3
4
1
2
3
4

首先執行statement，當while（expr）為真的的時候，返回循環，為假，跳出循環

---

阿發你好 第8章 函數

全局變量與局部變量

#include<stdio.h>
int arr[3]={0,1,2};
int main(){
printf("%d",arr[2]);
return 0;
}
1
2
3
4
5
6
1
2
3
4
5
6

函數的聲明

#include<stdio.h>
int find_q(int a);//函數聲明部分
int main(){return 0;
}
int find_q(int a){
statement;
}
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8

參數的默認值
1、具有默認值的參數必須在列的最后面
2、當函數的聲明與定義分來的時候，不能寫在定義里面

也就是說，在聲明里面添加默認值，不能寫在定義里面
#include<stdio.h>
void funtion(int a, int b, int c=1);
int main(){return 0;
}
void function(int a.int b, int c)
{
return 0;
}
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10

內聯函數 inline關鍵字

inline int max(int a, int b)
{return 0;
}
int main()
{int a=max(1,2);
}
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8

函數的遞歸

阿發你好 第9章 指針

指針類型用于表示地址
星號操作符號，直接用于指針變量上，直接用來讀寫內存值的
下面是代碼`#include
using namespace std;
int main()
{
int a = 0;
int *p = &a;
*p = 0x11;//修改內存里的內容
*p = 0x12;
a=0x14;
system(“pause”);
}

---

&以為向下走，也就是去取地址
*相當于往上走，去地址中的內容
*p 可以用修改地址中的內容，他的效果和a修改的效果是一樣
p則表示的a所在位置的地址。

#include <iostream>
using namespace std;
int main()
{int arr[4] = { 1, 2, 3, 4 };system("pause");
}
1
2
3
4
5
6
7
1
2
3
4
5
6
7

查看一個數組的地址，直接輸入數組名就可以了

數組名稱，本身就是一個內存的地址

指針的類型：
1、chat* ：表示一個char型變量的地址
2、short* : 表示一個short型變量的地址
3、int* : 表示一個int型變量的地址
4、float* : 表示一個float型變量的地址
5、double * ：表示一個double型變量的地址

在打印的地址的時候用%p來表示指針類型

#include <iostream>
using namespace std;
int main()
{int arr[4] = { 1, 2, 3, 4 };int *p1 = arr;int *p2 = &arr[0];//這兩句是等價的system("pause");
}
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10

這種寫法值得注意：int *p=arr；

指針的移動

#include <iostream>
using namespace std;
int main()
{int arr[4] = { 1, 2, 3, 4 };int *p1 = arr;int *p2 = &arr[0];//這兩句是等價的p1 += 1;cout << *p1;system("pause");
}
1
2
3
4
5
6
7
8
9
10
11
1
2
3
4
5
6
7
8
9
10
11

總結：等式左邊表示聲明他的類型

#include <iostream>
using namespace std;
int main()
{int arr[4] = { 1, 2, 3, 4 };int *p = &arr[1];p[0] = 0xAA;p[1] = 0xBB;return 0;system("pause");
}
1
2
3
4
5
6
7
8
9
10
11
1
2
3
4
5
6
7
8
9
10
11

也就是說通過p修改了數組arr中的元素
實例說明P修改arr中的元素

#include <iostream>
using namespace std;
int main()
{int arr[4] = { 1, 2, 3, 4 };int *p = arr;for (int i = 0; i < 4; ++i){p[i] += p[i];cout << p[i]<< endl;}for (int ii = 0; ii < 4;++ii){cout << arr[ii] << endl;}system("pause");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

把指針作為一個函數的參數來使用

#include <iostream>
using namespace std;
void test(int *p);
int main()
{int a =0x11;test(&a);system("pause");
}
void test(int *p)
{*p=0x12;cout << "change the value:" << *p << endl;}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

const int *p=&a;//也就是說明 p指針只能指向a，或者的表示只能讀，不能寫
int *const p=&a;//這就是說p不能被修改，而*p可以被修改
1
2
1
2

指針只能指向變量或者數組
野指針就是指的那個沒有指向變量和數組的指針
**空指針**iint *p=0;

#include <iostream>
using namespace std;
int main()
{int *p = 0;if (p){cout << "p不是一個空指針" << endl;}system("pause");
}
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12

說明輸出結果就時一個空指針
也就是說，當你傳入一個空指針的時候，一個函數是有辦法判斷他是不是一個空指針的

數組作為函數的參數

int arg(int *p, int len)
{int sum=0;
}
int main()
{int arr[]={0,1,2,3};int n;n=avg(arr,3)
}
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10

方法1、int avg(int *p,int len)
方法2、int avg(int p[],int len)
1
2
1
2

當數組作為函數的參數的時候的引用。

#include<stdio.h>
int avg(int*p,int len )
{int sum = 0;for (int i = 0; i < len; i++){sum += p[i];}return sum ;
}
int main(){int arr[4] = { 1, 2, 3, 4 };int rect = 0;rect = avg(arr, 4);printf("%d", rect);int a;getchar();//scanf("%d\n",&a);return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

指針類型作為函數的返回值

#include <iostream>
#include <stdlib.h>
int number = 1;
int *get()
{return &number;
}
int main()
{int *p = get();//*p = 12;printf("%d\n", p);printf("%d\n", *p);system("pause");return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

const指針
在普通的指針類型上加上關鍵字const修飾，叫做const指針類型
const的作用封禁了信號操作里的寫內存功能

int test(const int *p, int len)
{
}
1
2
3
1
2
3

const指針常用于限定函數參數
這個參數限定為const類型，用于顯式地指定：“該函數是輸入參數，在函數里只是讀取內存的值，而不會修改這個內存的值”

void * 型指針
void * 型指針僅僅表示一個內存地址，它不指明內存里的存放何種類型的數據。
void * 型指針不支持加減法

空指針的使用

int *p=0;//空指針
if(p)//用if語句來判斷指針類型是否為空值
{printf("%d\n",*p);
}
1
2
3
4
5
1
2
3
4
5

指針的使用規范：
1、杜絕野指針
當一個指針初始化的時候，要么將其置為空指針，要么將其指向為某個變量的地址
2、防止數組越界
3、目標內存是否已經生效
用一個指針指向一個變量，但是要注意這個變量的作用域。

二重指針

指針也是變量，凡是變量就是有地址

int **p=&q;
1
1

#include<stdio.h>
int number=0;
void set(int **p )
{*p=&number;
}
int main()
{int *p=NULL;set(&p);*p=23;return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
1
2
3
4
5
6
7
8
9
10
11
12
13

二維數組

順次打印這個行列式的值

#include <stdlib.h>
#include <iostream>
using namespace std;
void test(int data[][4], int rows)//打印這個行列式
{for (int i = 0; i < rows;i++){for (int j = 0; j < 4;j++){printf("%d\n", data[i][j]);}}
}
int main()
{int arr[2][4] ={{ 1, 2, 3, 4 },{ 11, 12, 13, 14 }, };test(arr, 2);system("pause");return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

二維數組和指針之間的變換

int aa[6][4];
int (* row0)[4]=aa;//row0:指向第0行
int (* row1)[4]=aa;//row1:指向第1行
(*row0)[0]=1;//第一種方法：使用指針的方式，訪問第0行第0列；
row0[0][1]=2;
row[0][0]=3;
1
2
3
4
5
6
1
2
3
4
5
6

阿發你好 第10章 結構體

結構體的定義和初始化

定義結構體數組

結構體的賦值：

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
struct Highschool
{char name;int num;int  phone;};
int main()
{Highschool a={ 'c', 1, 2 };Highschool b = a;//將a中的數據賦值給bcout << b.name << endl;system("pause");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

結構體訪問

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
struct Highschool
{char name;int num;int  phone;};
int main()
{Highschool a={ 'c', 1, 2 };Highschool *p = &a;cout << p->name << endl;//使用->箭頭來訪問結構體的成員變量（這是常用寫法）cout<<(*p).id<<endl;system("pause");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

結構體作為函數的參數

結構體作為函數的返回值

匿名struct

using namespace std;
struct 
{char name;int num;int  phone;} info;
int main()
{info.num = 1;cout << info.num << endl;system("pause");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注意事項：
大括號只能用于初始化、不能直接用在賦值上

strcpy 函數用于復制字符串，在使用之前需要向其中添加#include<string.h>
1
1

結構體的內存視圖

struct 
{int id;char name[8];
}obj
1
2
3
4
5
1
2
3
4
5

一個obj占據12個字節，一個char是占一個字節，那么一個id是4個字節，一個name[8]占據8個字節

結構體指針

contact *p=&a;//結構體加上相應的*號就相當于對應類型的指針類型
p->id=123;//對于結構體指針類型用->來訪問對象的數據成員
1
2
1
2

將結構體作為函數的參數

作為傳值方式

void test(contact a)
{
printf("id is %d/n name is %s",a.id,a.name)
}
1
2
3
4
1
2
3
4

作為傳地址的方式

void test(contact *a)
{
printf("id is %d/n name is %s/n",a->id, a->name);
}
1
2
3
4
1
2
3
4

作為函數的返回值

和基本的結構體一樣、結構體類型也可以作為函數返回值的類型

contact create（int id）
{contact a;a.id=id;return a;
} 
1
2
3
4
5
6
1
2
3
4
5
6

結構體作為結構體的成員函數

成員函數的類型也可以是結構體類型

struct color
{unsigned char r;unsigned char g;unsigned char b;
};
struct object
{int x,y;color rgb
};
1
2
3
4
5
6
7
8
9
10
11
1
2
3
4
5
6
7
8
9
10
11

object obj=
{1,2,{0xFF,0X00,0X00}}
1
2
3
4
5
6
7
1
2
3
4
5
6
7

結構體緊湊的表示方式

struct object
{
int x;
int y;
}a，*p;//在這里直接初始化兩個對象，一個結構體類型的a，和一個結構體指針類型的*p
1
2
3
4
5
1
2
3
4
5

傳值和傳地址

傳值-是說明：在傳遞參數的時候，如果傳入對象是一個值，那么就叫做傳值
傳地址-是說明：在傳遞參數的時候，如果傳入的對象是一個地址，那么就叫做傳地址

位字段 bit-filed

在結構體當中有一種特殊的成員，叫做位字段。他是在變量名后面加冒號，然后標明該字段到底占用了多少個位
Struct object
{
Unsigned char a : 1;
Unsigned char b : 2;
};
表明該字段到底是占了1位，如果是1位的話，則只能取值[0,1],占了2位，取值范圍[0~3],占了三位[0~7]

聯合體union

Union 在實際的工程當中，一般不會使用這個語法，學這個語法的目的，只是為了讀懂一種老舊的C語言代碼

Union somedata
{
Unsigned int a;
Unsigned char b;
Char c[10];
}
聯合體是共享同一片內存區域的

聯合體的大小就是所有成員里體積最大的那個成員的大小

阿發你好 第12章 動態分配內存

在操作系統中，有一個內存管理器（MM），
在C語言中，內存的管理和釋放用malloc/free這兩個函數來調用
malloc申請內存，申請的內存在堆區（heap）
一個系統當中只有一個內存管理器，系統中所有的進程都向同一個內存管理器來申請內存。
內存泄漏：就是程序長時間運行，如果不能及時清理內存，內存積累的就會越來越多，導致系統沒有內存空間可是使用，這種現象，就是內存泄漏。
對象的分類：
1、全局對象
2、局部對象
3、動態對象
一個對象就對應了一塊內存，對象的值就是內存里的數據

阿發你好 第13章 鏈表

鏈表是一種數據的組織方式

鏈表的構造

struct student
{int id;char name[16];student *next;//添加一個指針用于指向下一個對象
}
1
2
3
4
5
6
1
2
3
4
5
6

初始化一個結構體數組

student ss[4]=
{{123,"123",0},{123,"123",1},{123,"123",2}
}
1
2
3
4
5
6
1
2
3
4
5
6

將這三個對象串聯起來

ss[0].next=&ss[1];
ss[1].next=&ss[2];
ss[2].next=0;
1
2
3
1
2
3

頭結點和末節點

//當若干個對象別串起來的時候，只需要添加第一個對象，就可以訪問到鏈表中的每一個對象
student *p=&ss[0];
while(p)
{printf("%d,%s",p->id,p->name)p=p->next;//指向下一個對象
}
1
2
3
4
5
6
7
1
2
3
4
5
6
7

鏈表頭的作用：鏈表頭可以用于代表整個鏈表

有頭鏈表

有一個固定的頭節點來指代整個鏈表，所有的對象都掛在這個頭節點下面，而頭節點本身不包含有效數據
使用頭鏈表的目的是，簡化鏈表的操作使之容易實現
頭部的節點稱為頭節點，后面的節點稱為數據節點
這個部分我就先跳過了，等有機會再去寫吧

阿發你好 第14章 引用

struct object
{int value;
}
int main()
{object a = {1};object &r =a;//r相當于a的一個別名
}
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9

指針和引用的最大的區別在于：引用在定義的時候，必須關聯到一個對象。而指針的話，不必在初始化的時候就指向一個對象，可以指向一個空指針

int a=123;
int &r=a;
1
2
1
2

object a={1};
object &r=a;
object *p=&r;
1
2
3
1
2
3

作為函數的參數

void test(object &r)
{r.value=1;
}
int main（）
{object a={1};test(a);return 0;
}
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10

作為函數的返回值

object the_object={123};
object *test()
{
return &the_object;
}
int main()
{object *p=test();p->value=456;return 0;
}
1
2
3
4
5
6
7
8
9
10
11
1
2
3
4
5
6
7
8
9
10
11

阿發你好 第15章

C風格字符串
字符串通常以3種形式存在：字符數組、動態字符串常量和字符串常量
字符串數組
并不是所有的char*都叫做字符串，實際上，只有當這塊內存用于存儲字符串的時候，我們才稱他為字符串，如果只是把它用于存儲于一些普通的數據，則不能不他稱為字符串。

遍歷字符串

遍歷字符串，有兩種方法：1、索引遍歷；2、指針遍歷。

字符串的比較

在<string.h>中、用strcmp函數來比較這兩個字符串
1
1

字符串的插入與刪除
字符串的分割
使用數組還是指針？
1、數組的方式
優點：1、安全，不必維護指針
2、操作簡單
缺點：1、浪費空間
2、不適用較長的字符串

阿發你好 第16章 標準C語言庫

標準C語言庫也被稱為：ANSI C 函數庫

stdio.h

getchar()、putchar()//向控制臺輸入、輸出一個字符
gets()、puts()//輸入字符串、輸出字符串
sprintf、sscanf()//

math.h

abs 取絕對值
ceil 向上取整
floor 向下取整
pow 求x的y次冪
sqrt 求平方根

time.h

time_t是一個typedef

stdlib.h

atoi/atof 字符串轉化成數字
rand/srand 隨機數生成
以及system里面的函數

stdio.h

1、fopen：打開文件
2、fwrite: 寫入數據
3、fclose: 關閉文件
1
2
3
1
2
3

阿發你好 第17章 文件操作

#include<stdio.h>
int main()
{const char *filename="c:/aaa.txt";FILE * fp=fopen(filename,"rb");if(fp==NULL){printf("fail to open file");return -1;}char buf[123];int n=fread(buf,1,123,fp);fclose(fp);return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

數據的存儲格式

存儲char類型的整數

char ch=12;
fwrite(&ch,1,1,fp);//存入
fread(&ch,1,1,fp);//讀取
1
2
3
1
2
3

存儲int型的整數

int n=12;
fwrite(&n,1,sizeof(int),fp);//存
fread(&n,1,sizeof(int),fp);//取
1
2
3
1
2
3

存取double類型的小數

double value=23.23;
fwrite(&value,1,sizeof(value),fp);
fread(&value,1,sizeof(value),fp);
1
2
3
1
2
3

存取結構體型數據

object obj={123};
fwrite(&obj,1,sizeof(value),fp);
fread(&obj,1,sizeof(value),fp);
1
2
3
1
2
3

存取字符串結構

char name[32]="adf";
fwrite(name,1,sizeof(name),fp);
fread(name,1,sizeof(name),fp);
1
2
3
1
2
3

指針指向的對象

Run-Length Encoding 存儲

RLE是一種常見的編碼技術、用于存儲字符串的信息
fprintf是一種按行進行格式化寫入
fgets是按行進行讀取

文件的隨機訪問

順序訪問：按照順序訪問，不能隨意跳躍
隨機訪問：可以任意調到一個任何位置進行訪問
fseek隨機訪問
文件的打開模式：
wb是寫模式，rb是讀模式

阿發你好 第18章 多文件項目以及編程過程

extern 聲明全局函數

假設一個項目里面有A.cpp和B.cpp，我想實現在A.cpp當中調用B.cpp里定義的函數

extern 聲明全局變量

extern的作用是通知編輯器，在本CPP中要用到某個符號，這個符號可能不在本cpp中定義

多文件項目的生成

C++項目生成過程主要分成2步：1、編譯；2、鏈接
在編譯階段：cpp文件中的代碼轉換成中間文件

全量編譯和增量編譯

全量編譯：將所有的CPP 文件都編譯一遍
和增量編譯：只對改變的量進行編譯

宏定義#define指定

所有以#為開頭的行都是預處理指令

#define 語法就是對他進行原文替換
1
1

常見的幾個宏定義

1、NULL 空指針

#define NULL 0
或者
#define NULL (void*) 0
1
2
3
1
2
3

條件編譯指令 #if … #endif

條件編譯指令 #ifdef … #endif

#ifdef 表示如果對應的宏有定義，那么則相應的代碼被編譯
同時也可以用#undef來去除定義
1
2
1
2

#ifndef 表示的意思和 #ifdef恰好相反
也就是說，當對應的宏不存在的時候，才能編譯相應的代碼
1
2
1
2

int main(int argc, char **argv)
1
1

static

static 表示的是靜態變量，當static修飾一個函數，稱為靜態函數，當static修飾一個變量的時候，稱為靜態變量。