C++快速掃盲（基礎篇）

第一個C++程式

#include<iostream>
using namespace std;

int main() {

  cout << "Hello world" << endl;

  system("pause");

  return 0;
}      

注釋

作用：在代碼中加一些說明和解釋，友善自己或其他程式員程式員閱讀代碼

兩種格式

1. 單行注釋：​

   ​// 描述資訊​

   ​

• 通常放在一行代碼的上方，或者一條語句的末尾，對該行代碼說明

1. 多行注釋：​

   ​/* 描述資訊 */​

   ​

• 通常放在一段代碼的上方，對該段代碼做整體說明

變量

作用：給一段指定的記憶體空間起名，友善操作這段記憶體

文法：​

​資料類型 變量名 = 初始值;​

​

示例：

#include<iostream>
using namespace std;

int main() {

  //變量的定義
  //文法：資料類型  變量名 = 初始值

  int a = 10;

  cout << "a = " << a << endl;
  
  system("pause");

  return 0;
}      

注意：C++在建立變量時，必須給變量一個初始值，否則會報錯

常量

作用：用于記錄程式中不可更改的資料

C++定義常量兩種方式

1. #define 宏常量： ​

   ​#define 常量名 常量值​

   ​

• 通常在檔案上方定義，表示一個常量

1. const修飾的變量 ​

   ​const 資料類型 常量名 = 常量值​

   ​

• 通常在變量定義前加關鍵字const，修飾該變量為常量，不可修改

關鍵字

作用： 關鍵字是C++中預先保留的單詞（辨別符）

• 在定義變量或者常量時候，不要用關鍵字

C++關鍵字如下：

asm	do	if	return	typedef
auto	double	inline	short	typeid
bool	dynamic_cast	int	signed	typename
break	else	long	sizeof	union
case	enum	mutable	static	unsigned
catch	explicit	namespace	static_cast	using
char	export	new	struct	virtual
class	extern	operator	switch	void
const	false	private	template	volatile
const_cast	float	protected	this	wchar_t
continue	for	public	throw	while
default	friend	register	true
delete	goto	reinterpret_cast	try

​

​提示：在給變量或者常量起名稱時候，不要用C++得關鍵字，否則會産生歧義。​

​

辨別符命名規則

作用：C++規定給辨別符（變量、常量）命名時，有一套自己的規則

• 辨別符不能是關鍵字
• 辨別符隻能由字母、數字、下劃線組成
• 第一個字元必須為字母或下劃線
• 辨別符中字母區分大小寫

建議：給辨別符命名時，争取做到見名知意的效果，友善自己和他人的閱讀

整型

作用：整型變量表示的是整數類型的資料

C++中能夠表示整型的類型有以下幾種方式，差別在于所占記憶體空間不同：

資料類型	占用空間	取值範圍
short(短整型)	2位元組	(-2^15 ~ 2^15-1)
int(整型)	4位元組	(-2^31 ~ 2^31-1)
long(長整形)	Windows為4位元組，Linux為4位元組(32位)，8位元組(64位)	(-2^31 ~ 2^31-1)
long long(長長整形)	8位元組	(-2^63 ~ 2^63-1)

sizeof關鍵字

**作用：**利用sizeof關鍵字可以統計資料類型所占記憶體大小

文法： ​

​sizeof( 資料類型 / 變量)​

​

示例：

int main() {

  cout << "short 類型所占記憶體空間為： " << sizeof(short) << endl;

  cout << "int 類型所占記憶體空間為： " << sizeof(int) << endl;

  cout << "long 類型所占記憶體空間為： " << sizeof(long) << endl;

  cout << "long long 類型所占記憶體空間為： " << sizeof(long long) << endl;

  system("pause");

  return 0;
}      

整型結論：short < int <= long <= long long

實型（浮點型）

作用：用于表示小數

浮點型變量分為兩種：

1. 單精度float
2. 雙精度double

兩者的差別在于表示的有效數字範圍不同。

資料類型	占用空間	有效數字範圍
float	4位元組	7位有效數字
double	8位元組	15～16位有效數字

字元型

**作用：**字元型變量用于顯示單個字元

文法：​

​char ch = 'a';​

​

注意1：在顯示字元型變量時，用單引号将字元括起來，不要用雙引号

注意2：單引号内隻能有一個字元，不可以是字元串

• C和C++中字元型變量隻占用1個位元組。
• 字元型變量并不是把字元本身放到記憶體中存儲，而是将對應的ASCII編碼放入到存儲單元

ASCII碼表格：

ASCII值	控制字元	ASCII值	字元	ASCII值	字元	ASCII值	字元
NUT	32	(space)	64	@	96	、
1	SOH	33	!	65	A	97	a
2	STX	34	"	66	B	98	b
3	ETX	35	#	67	C	99	c
4	EOT	36	$	68	D	100	d
5	ENQ	37	%	69	E	101	e
6	ACK	38	&	70	F	102	f
7	BEL	39	,	71	G	103	g
8	BS	40	(	72	H	104	h
9	HT	41	)	73	I	105	i
10	LF	42	*	74	J	106	j
11	VT	43	+	75	K	107	k
12	FF	44	,	76	L	108	l
13	CR	45	-	77	M	109	m
14	SO	46	.	78	N	110	n
15	SI	47	/	79	O	111	o
16	DLE	48	80	P	112	p
17	DCI	49	1	81	Q	113	q
18	DC2	50	2	82	R	114	r
19	DC3	51	3	83	S	115	s
20	DC4	52	4	84	T	116	t
21	NAK	53	5	85	U	117	u
22	SYN	54	6	86	V	118	v
23	TB	55	7	87	W	119	w
24	CAN	56	8	88	X	120	x
25	EM	57	9	89	Y	121	y
26	SUB	58	:	90	Z	122	z
27	ESC	59	;	91	[	123	{
28	FS	60	<	92	/	124	|
29	GS	61	=	93	]	125	}
30	RS	62	>	94	^	126	`
31	US	63	?	95	_	127	DEL

ASCII 碼大緻由以下兩部分組成：

• ASCII 非列印控制字元： ASCII 表上的數字0-31配置設定給了控制字元，用于控制像列印機等一些外圍裝置。
• ASCII 列印字元：數字32-126配置設定給了能在鍵盤上找到的字元，當檢視或列印文檔時就會出現。

轉義字元

作用用于表示一些不能顯示出來的ASCII字元

現階段我們常用的轉義字元有：​

​\n \\ \t​

​

轉義字元	含義	ASCII碼值（十進制）
\a	警報	007
\b	倒退(BS) ，将目前位置移到前一列	008
\f	換頁(FF)，将目前位置移到下頁開頭	012
\n	換行(LF) ，将目前位置移到下一行開頭	010
\r	回車(CR) ，将目前位置移到本行開頭	013
\t	水準制表(HT) （跳到下一個TAB位置）	009
\v	垂直制表(VT)	011
\\	代表一個反斜線字元""	092
’	代表一個單引号（撇号）字元	039
"	代表一個雙引号字元	034
?	代表一個問号	063
\0	數字0	000
\ddd	8進制轉義字元，d範圍0~7	3位8進制
\xhh	16進制轉義字元，h範圍09，af，A~F	3位16進制

字元串型

作用：用于表示一串字元

兩種風格

1. C風格字元串： ​

   ​char 變量名[] = "字元串值"​

   ​示例：

int main() {

  char str1[] = "hello world";
  cout << str1 << endl;
    
  system("pause");

  return 0;
}      

注意：C風格的字元串要用雙引号括起來

1. C++風格字元串： ​

   ​string 變量名 = "字元串值"​

   ​示例：

int main() {

  string str = "hello world";
  cout << str << endl;
  
  system("pause");

  return 0;
}      

注意：C++風格字元串，需要加入頭檔案==#include<string>==

布爾類型 bool

**作用：**布爾資料類型代表真或假的值

bool類型隻有兩個值：

• true — 真（本質是1）
• false — 假（本質是0）

bool類型占1個位元組大小

資料的輸入

作用：用于從鍵盤擷取資料

**關鍵字：**cin

文法： ​

​cin >> 變量​

​

示例：

int main(){

  //整型輸入
  int a = 0;
  cout << "請輸入整型變量：" << endl;
  cin >> a;
  cout << a << endl;

  //浮點型輸入
  double d = 0;
  cout << "請輸入浮點型變量：" << endl;
  cin >> d;
  cout << d << endl;

  //字元型輸入
  char ch = 0;
  cout << "請輸入字元型變量：" << endl;
  cin >> ch;
  cout << ch << endl;

  //字元串型輸入
  string str;
  cout << "請輸入字元串型變量：" << endl;
  cin >> str;
  cout << str << endl;

  //布爾類型輸入
  bool flag = true;
  cout << "請輸入布爾型變量：" << endl;
  cin >> flag;
  cout << flag << endl;
  system("pause");
  return EXIT_SUCCESS;
}      

算術運算符

作用：用于處理四則運算

算術運算符包括以下符号：

運算符	術語	示例	結果
+	正号	+3	3
-	負号	-3	-3
+	加	10 + 5	15
-	減	10 - 5	5
*	乘	10 * 5	50
/	除	10 / 5	2
%	取模(取餘)	10 % 3	1
++	前置遞增	a=2; b=++a;	a=3; b=3;
++	後置遞增	a=2; b=a++;	a=3; b=2;
–	前置遞減	a=2; b=–a;	a=1; b=1;
–	後置遞減	a=2; b=a–;	a=1; b=2;

指派運算符

**作用：**用于将表達式的值賦給變量

指派運算符包括以下幾個符号：

運算符	術語	示例	結果
=	指派	a=2; b=3;	a=2; b=3;
+=	加等于	a=0; a+=2;	a=2;
-=	減等于	a=5; a-=3;	a=2;
*=	乘等于	a=2; a*=2;	a=4;
/=	除等于	a=4; a/=2;	a=2;
%=	模等于	a=3; a%2;	a=1;

比較運算符

作用用于表達式的比較，并傳回一個真值或假值

比較運算符有以下符号：

運算符	術語	示例	結果
==	相等于	4 == 3
!=	不等于	4 != 3	1
<	小于	4 < 3
>	大于	4 > 3	1
<=	小于等于	4 <= 3
>=	大于等于	4 >= 1	1

邏輯運算符

作用用于根據表達式的值傳回真值或假值

邏輯運算符有以下符号：

運算符	術語	示例	結果
!	非	!a	如果a為假，則!a為真； 如果a為真，則!a為假。
&&	與	a && b	如果a和b都為真，則結果為真，否則為假。
||	或	a || b	如果a和b有一個為真，則結果為真，二者都為假時，結果為假。

if語句

作用執行滿足條件的語句

if語句的三種形式

• 單行格式if語句
• 多行格式if語句
• 多條件的if語句

switch語句

作用：執行多條件分支語句

文法：

switch(表達式)

{

  case 結果1：執行語句;break;

  case 結果2：執行語句;break;

  ...

  default:執行語句;break;

}      

while循環語句

作用： 滿足循環條件，執行循環語句

文法：​

​while(循環條件){ 循環語句 }​

​

解釋：隻要循環條件的結果為真，就執行循環語句

do…while循環語句

作用： 滿足循環條件，執行循環語句

文法： ​

​do{ 循環語句 } while(循環條件);​

​

**注意：**與while的差別在于do…while會先執行一次循環語句，再判斷循環條件

for循環語句

作用： 滿足循環條件，執行循環語句

文法：​

​for(起始表達式;條件表達式;末尾循環體) { 循環語句; }​

​

break語句

作用: 用于跳出選擇結構或者循環結構

break使用的時機：

• 出現在switch條件語句中，作用是終止case并跳出switch
• 出現在循環語句中，作用是跳出目前的循環語句
• 出現在嵌套循環中，跳出最近的内層循環語句

continue語句

**作用：**在循環語句中，跳過本次循環中餘下尚未執行的語句，繼續執行下一次循環

一維數組定義方式

一維數組定義的三種方式：

1. ​

   ​資料類型 數組名[ 數組長度 ];​

   ​
2. ​

   ​資料類型 數組名[ 數組長度 ] = { 值1，值2 ...};​

   ​
3. ​

   ​資料類型 數組名[ ] = { 值1，值2 ...};​

   ​

二維數組定義方式

二維數組定義的四種方式：

1. ​

   ​資料類型 數組名[ 行數 ][ 列數 ];​

   ​
2. ​

   ​資料類型 數組名[ 行數 ][ 列數 ] = { {資料1，資料2 } ，{資料3，資料4 } };​

   ​
3. ​

   ​資料類型 數組名[ 行數 ][ 列數 ] = { 資料1，資料2，資料3，資料4};​

   ​
4. ​

   ​資料類型 數組名[ ][ 列數 ] = { 資料1，資料2，資料3，資料4};​

   ​

函數的常見樣式

常見的函數樣式有4種

1. 無參無返
2. 有參無返
3. 無參有返
4. 有參有返

示例：

//函數常見樣式
//1、 無參無返
void test01()
{
  //void a = 10; //無類型不可以建立變量,原因無法配置設定記憶體
  cout << "this is test01" << endl;
  //test01(); 函數調用
}

//2、 有參無返
void test02(int a)
{
  cout << "this is test02" << endl;
  cout << "a = " << a << endl;
}

//3、無參有返
int test03()
{
  cout << "this is test03 " << endl;
  return 10;
}

//4、有參有返
int test04(int a, int b)
{
  cout << "this is test04 " << endl;
  int sum = a + b;
  return sum;
}      

指針變量的定義和使用

指針變量定義文法： ​

​資料類型 * 變量名；​

​

示例：

int main() {

  //1、指針的定義
  int a = 10; //定義整型變量a
  
  //指針定義文法： 資料類型 * 變量名 ;
  int * p;

  //指針變量指派
  p = &a; //指針指向變量a的位址
  cout << &a << endl; //列印資料a的位址
  cout << p << endl;  //列印指針變量p

  //2、指針的使用
  //通過*操作指針變量指向的記憶體
  cout << "*p = " << *p << endl;

  system("pause");

  return 0;
}      

指針變量和普通變量的差別

• 普通變量存放的是資料,指針變量存放的是位址
• 指針變量可以通過" * "操作符，操作指針變量指向的記憶體空間，這個過程稱為解引用

空指針和野指針

空指針：指針變量指向記憶體中編号為0的空間

用途： 初始化指針變量

注意： 空指針指向的記憶體是不可以通路的

示例1：空指針

int main() {

  //指針變量p指向記憶體位址編号為0的空間
  int * p = NULL;

  //通路空指針報錯 
  //記憶體編号0 ~255為系統占用記憶體，不允許使用者通路
  cout << *p << endl;

  system("pause");

  return 0;
}      

野指針：指針變量指向非法的記憶體空間

示例2：野指針

int main() {

  //指針變量p指向記憶體位址編号為0x1100的空間
  int * p = (int *)0x1100;

  //通路野指針報錯 
  cout << *p << endl;

  system("pause");

  return 0;
}      

const修飾指針

const修飾指針有三種情況

1. const修飾指針 — 常量指針
2. const修飾常量 — 指針常量
3. const即修飾指針，又修飾常量

示例：

int main() {

    int a = 10;
    int b = 10;

    //const修飾的是指針，指針指向可以改，指針指向的值不可以更改
    const int * p1 = &a; 
    p1 = &b; //正确
    //*p1 = 100;  報錯
    

    //const修飾的是常量，指針指向不可以改，指針指向的值可以更改
    int * const p2 = &a;
    //p2 = &b; //錯誤
    *p2 = 100; //正确

    //const既修飾指針又修飾常量
    const int * const p3 = &a;
    //p3 = &b; //錯誤
    //*p3 = 100; //錯誤

    system("pause");

    return 0;
}      

指針和數組

**作用：**利用指針通路數組中元素

示例：

int main() {

  int arr[] = { 1,2,3,4,5,6,7,8,9,10 };

  int * p = arr;  //指向數組的指針

  cout << "第一個元素： " << arr[0] << endl;
  cout << "指針通路第一個元素： " << *p << endl;

  for (int i = 0; i < 10; i++)
  {
    //利用指針周遊數組
    cout << *p << endl;
    p++;
  }

  system("pause");

  return 0;
}      

指針和函數

作用： 利用指針作函數參數，可以修改實參的值

示例：

//值傳遞
void swap1(int a ,int b)
{
  int temp = a;
  a = b; 
  b = temp;
}
//位址傳遞
void swap2(int * p1, int *p2)
{
  int temp = *p1;
  *p1 = *p2;
  *p2 = temp;
}

int main() {

  int a = 10;
  int b = 20;
  swap1(a, b); // 值傳遞不會改變實參

  swap2(&a, &b); //位址傳遞會改變實參

  cout << "a = " << a << endl;

  cout << "b = " << b << endl;

  system("pause");

  return 0;
}      

結構體定義和使用

文法：​

​struct 結構體名 { 結構體成員清單 }；​

​

通過結構體建立變量的方式有三種：

• struct 結構體名 變量名
• struct 結構體名 變量名 = { 成員1值 ， 成員2值…}
• 定義結構體時順便建立變量

示例：

//結構體定義
struct student
{
  //成員清單
  string name;  //姓名
  int age;      //年齡
  int score;    //分數
}stu3; //結構體變量建立方式3 


int main() {

  //結構體變量建立方式1
  struct student stu1; //struct 關鍵字可以省略

  stu1.name = "張三";
  stu1.age = 18;
  stu1.score = 100;
  
  cout << "姓名：" << stu1.name << " 年齡：" << stu1.age  << " 分數：" << stu1.score << endl;

  //結構體變量建立方式2
  struct student stu2 = { "李四",19,60 };

  cout << "姓名：" << stu2.name << " 年齡：" << stu2.age  << " 分數：" << stu2.score << endl;


  stu3.name = "王五";
  stu3.age = 18;
  stu3.score = 80;
  

  cout << "姓名：" << stu3.name << " 年齡：" << stu3.age  << " 分數：" << stu3.score << endl;

  system("pause");

  return 0;
}      

總結1：定義結構體時的關鍵字是struct，不可省略

總結2：建立結構體變量時，關鍵字struct可以省略

總結3：結構體變量利用操作符 ‘’.’’ 通路成員

結構體數組

作用： 将自定義的結構體放入到數組中友善維護

文法：​

​struct 結構體名 數組名[元素個數] = { {} , {} , ... {} }​

​

示例：

//結構體定義
struct student
{
  //成員清單
  string name;  //姓名
  int age;      //年齡
  int score;    //分數
}

int main() {
  
  //結構體數組
  struct student arr[3]=
  {
    {"張三",18,80 },
    {"李四",19,60 },
    {"王五",20,70 }
  };

  for (int i = 0; i < 3; i++)
  {
    cout << "姓名：" << arr[i].name << " 年齡：" << arr[i].age << " 分數：" << arr[i].score << endl;
  }

  system("pause");

  return 0;
}      

結構體指針

作用： 通過指針通路結構體中的成員

• 利用操作符​

  ​->​

  ​可以通過結構體指針通路結構體屬性

//結構體定義
struct student
{
  //成員清單
  string name;  //姓名
  int age;      //年齡
  int score;    //分數
};


int main() {
  
  struct student stu = { "張三",18,100, };
  
  struct student * p = &stu;
  
  p->score = 80; //指針通過 -> 操作符可以通路成員

  cout << "姓名：" << p->name << " 年齡：" << p->age << " 分數：" << p->score << endl;
  
  system("pause");

  return 0;
}