C++基礎

Posted on 2024-06-24 21:14 來顆維C 閱讀(58) 評論(0) 收藏舉報

一、C++第一個項目

入門技巧

1.使用解決方案資源管理器窗口添加/管理文件

2.使用團隊資源管理器窗口連接到源代碼管理

3.使用輸出窗口查看生成輸出和其他消息

4.使用錯誤列表窗口查看錯誤

5.轉到"項目"-->"添加新項"以創(chuàng)建新的代碼文件或者轉到"項目"-->"添加現(xiàn)有項"添加到項目中

6.將來若要再次打開此項目,選擇.sIn文件

代碼:

#include <iostream>  //包含的頭文件

using namespace std;  //缺省指定的命名空間

int main()   //程序入口 程序執(zhí)行的入口 每個程序有且僅有一個main函數(shù)
{
 //<< 輸出運算符
 //cout 向控制臺輸出內容的指令
 // ; C++語句結束符
	cout << "HelloWorld!" << endl;      

	return 0;
}

二、C++輸出數(shù)據

數(shù)據是信息的載體,寫程序的目的就是為了處理數(shù)據

1.數(shù)據的分類

數(shù)據有數(shù)字、字符和字符串三種類型

數(shù)字：直接書寫，如100、89、23；

字符：用半角的單引號包含的一個符號，如：'A'、'z'、'0'、‘9’ 、‘~’、‘+’等；

字符串：用半角的雙引號包含的多個符號，如："Hello World";

2.輸出數(shù)據

std::cout 可以輸出各種類型的數(shù)據;

<<操作符可以拼接多個數(shù)據項;

std::eddl 也可以用于換行;

using namespace std;制定缺省的命名空間

3.示例代碼

#include <iostream>
using namespace std;

int main()
{
	//用于多個數(shù)據項的輸出: 姓名、年齡、性別、學號、專業(yè)
	cout << "姓名" << "C++初學者" << endl << "年齡:" << 25 << endl << "性別:" << "男" << endl << "學號:" << 20990164 << endl << "專業(yè):" << "計算機科學與技術" << endl;
	return 0;
}

解決VS編譯中文報錯 error C2001:常量中有換行符

產生原因：文件中有中文字符，但是文件是utf-8格式的，使用msvc編譯器編譯時就會產生上述錯誤

解決辦法：

方式1(不推薦試了沒用)：

? 通過在項目里設置編譯選項，/utf-8

? 項目->右鍵屬性->C/C++ -> 命令行，在下方輸入框添加 /utf-8，就會在編譯時采用utf-8編碼來編譯

方式3:(親測可用已解決,但是這種方法會使原有項目在使用vs打開時出現(xiàn)中文亂碼)

打開控制面板-->找到時鐘和區(qū)域

找到區(qū)域

點擊管理-->更改系統(tǒng)區(qū)域設置

勾選上Beta-->重啟電腦

三、指針的基本概念

1、變量的地址

變量是內存變量的簡稱，在C++中，每定義一個變量，系統(tǒng)就會給變量分配一塊內存，內存是有地址的。

c++中使用運算符&獲取變量在內存中的起始地址。

2指針變量

指針變量簡稱指針，它是一種特殊的變量，專門用于存放變量在內存中的起始地址。

語法：數(shù)據類型*變量名；

數(shù)據類型必須是合法的C++數(shù)據類型

#include <iostream>

using namespace std;

int main()
{
	int a;
	char b;
	bool c;
	string d;

	//int* pa = &a;  //讓指針pa指向變量a
	//char* pb = &b; //r讓指針pb指向變量b
	//bool* pc = &c;
	//string* pd = &d;

	int* pa;  //定義指針pa
	char* pb;
	bool* pc;
	string* pd;

	a = 1;

	/*cout << "變量a的地址是:" << (long long)&a << endl;
	cout << "變量b的地址是:" << (long long)&b << endl;
	cout << "變量c的地址是:" << (long long)&c << endl;
	cout << "變量d的地址是:" << (long long)&d << endl;
	cout << endl;

	cout << "指針變量a的地址是:" << (long long)pa << endl;
	cout << "指針變量b的地址是:" << (long long)pb << endl;
	cout << "指針變量c的地址是:" << (long long)pc << endl;
	cout << "指針變量d的地址是:" << (long long)pd << endl;
	cout << endl;

	cout << sizeof(pa) << endl;
	cout << sizeof(pb) << endl;
	cout << sizeof(pc) << endl;
	cout << sizeof(pd) << endl;

	return 0;*/
}

3.使用指針

聲明指針變量后，在沒有賦值之前，里面是亂七八糟的值，這時候不能使用指針。
指針存放變量的地址，因此，指針名表示的是地址（就像變量名可以表示變量的值一樣）
*運算符被稱為間接值或解除引用（解引用）運算符，將它用于指針，可以得到該地址的內存中存儲
的值， *也是乘法符號， C++根據上下文來確定所指的是乘法還是解引用
#include<iostream>
using namespace std;
int main()
{
//定義一個變量
	int a;
	//初始化變量
	a = 3;

	//定義一個指針
	int* p = &a;

	//輸出a的值
	cout << "a=" << a << endl;
	cout << "*p=" << *p << endl;

	//對指針p解引用并且賦值
	*p = 8;
	cout << "a=" << a << endl;
	cout << "*p=" << *p << endl;

}

4.指針用于函數(shù)的參數(shù)

如果把函數(shù)的形參聲明為指針,調用的時候把參數(shù)的地址傳進去,形參中存放的是實參的地址,在函數(shù)中通過解引用的方法直接操作內存中的數(shù)據,可以修改實參的值,這種方法稱為地址傳遞或者傳地址

傳地址的意義:可以在函數(shù)中修改實參的值.減少內存拷貝,提升性能
#include <iostream>

using namespace std;

//函數(shù)聲明
void func(int num, string str);

int main()
{
	int bh = 3;
	string message = "峽谷掉分王";

	//函數(shù)調用
	func(bh, message);
	/*下邊代碼模擬函數(shù)調用的過程,等同于func(bh,message);
	 *{
		int num = bh;
		string str = message;
		cout << "親愛的" << num << "號:" << str << endl;
	}*/
}

//函數(shù)定義
void func(int num, string str)
{
	cout << "王者榮耀" << num << "號:" << str << endl;
}
值傳遞:在代碼中修改形參的不會改變實參的值

四、用const修飾指針

1、常量指針

語法:const 數(shù)據類型 *變量名

不能通過解引用的方法修改內存地址中的值（用原始的變量名是可以修改的）

#include <iostream>

using namespace std;

int main()
{
	//定義普通變量 語法:數(shù)據類型 變量名;
	int a = 3;
	int b = 8;

	//定義常量指針 語法:const 數(shù)據類型 *變量名
	const int* p = &a;  //使用取地址符&將普通變量a的值復制給常量指針p
	cout << "a=" << a << endl;  //輸出結果 3
	cout << "*p=" << *p << endl;  //輸出結果 3

}

輸出結果

通過解引用修改常量指針的值

#include <iostream>

using namespace std;

int main()
{
	//定義普通變量 語法:數(shù)據類型 變量名;
	int a = 3;
	int b = 8;

	//定義常量指針 語法:const 數(shù)據類型 *變量名
	const int* p = &a;  //使用取地址符&將普通變量a的值復制給常量指針p

 //修改常量指針的值
	*p = 13; //這種方式是通過解引用的方法修改內存地址中的值 報錯

	cout << "a=" << a << endl;  //輸出結果 3
	cout << "*p=" << *p << endl;  //輸出結果 3


}

運行報錯

用原始變量名可以修改

#include <iostream>

using namespace std;

int main()
{
	//定義普通變量 語法:數(shù)據類型 變量名;
	int a = 3;
	int b = 8;

	//定義常量指針 語法:const 數(shù)據類型 *變量名
	const int* p = &a;  //使用取地址符&將普通變量a的值復制給常量指針p

	//修改常量指針的值
	//*p = 13; //這種方式是通過解引用的方法修改內存地址中的值

	//用原始變量名修改內存地址中的值(可以修改)
	a = 13;

	cout << "a=" << a << endl;  //輸出結果 3
	cout << "*p=" << *p << endl;  //輸出結果 3
}

運行結果(可以修改成功)

指向變量(對象可以改變)(之前是指向變量a的后來可以改為指向變量b)

#include <iostream>

using namespace std;

int main()
{
	//定義普通變量 語法:數(shù)據類型 變量名;
	int a = 3;
	int b = 8;

	//定義常量指針 語法:const 數(shù)據類型 *變量名
	const int* p = &a;  //使用取地址符&將普通變量a的值復制給常量指針p

	//修改常量指針的值
	//*p = 13; //這種方式是通過解引用的方法修改內存地址中的值

	//用原始變量名修改內存地址中的值(可以修改)
	a = 13;

	cout << "a=" << a << endl;  //輸出結果 3
	cout << "*p=" << *p << endl;  //輸出結果 3

	//原本是指向a修改后指向b
	p = &b;
	cout << "b=" << endl;
	cout << "p=" << *p << endl;
}

常量指針的應用場景

一般用于修飾函數(shù)的參數(shù),表示不希望在函數(shù)里修改內存地址的值

2、指針常量

語法: 數(shù)據類型 *const 變量名

指向的變(對象)不可以改變,在定義的同時必須初始化;可以通過解引用的方法修改內存地址中的值
在定義的同時必須初始化(沒有初始值會報錯)
在定義的時候賦初始值
指向變量不可以改變(之前是指向變量a 不可以再指向變量b)
#include <iostream>
using namespace std;


int main()
{
  int a = 3;
	int b = 8;
	int* const p = &a;
	//使用解引用的方法去修改內存地址中的值
	*p = 13;
	cout << "a=" << a << endl;
	cout << "*p=" << *p << endl;

	//之前指向a,現(xiàn)在將指針常量指向b  不可以改變
	p = &b;//報錯
}

3、常指針常量

語法: const 數(shù)據類型 *const 變量名;
指向變量(對象)不可以改變 不能通過解引用的方法修改內存地址中的值

4、常量指針、指針常量、常指針常量

常量指針：原先常量指針的指向原始變量a，可以通過修改原始變量a的值來修改常量指針的值，但是不能通過修修改指針變量的值來修改原始變量的值；并且常量指針可以有原先指向變量a改為轉向變量b;
//定義普通變量 語法:數(shù)據類型 變量名;
	int a = 3;
	int b = 8;

	//定義常量指針 語法:const 數(shù)據類型 *變量名
	const int* p = &a;  //使用取地址符&將普通變量a的值復制給常量指針p

	//修改常量指針的值
	//*p = 13; //這種方式是通過解引用的方法修改內存地址中的值 報錯

	//用原始變量名修改內存地址中的值(可以修改)
	a = 13;

	cout << "a=" << a << endl;  //輸出結果 3
	cout << "*p=" << *p << endl;  //輸出結果 3

	//原本是指向a 可以指向b
	p = &b;
	cout << "b=" << b << endl;
	cout << "p=" << *p << endl;
指針常量：原先指針常量指向原始變量a，可以通過修改常量指針的值來修改原始變量a的值，并且指針常量不可以由原先指向變量a改為轉向變量b;

常指針常量：指針指向不可以改，指針指向的值也不可以該（原先指針常量指向原始變量a，不可以通過修改常量指針的值來修改原始變量a的值，不可以由原先指向變量a改為轉向變量b;）

5、void關鍵字

在C++中，void 表示無類型，主要三個用途：

函數(shù)的返回值用void,表示函數(shù)沒有返回值。
void func(int ,int b)
{
 //函數(shù)體代碼
 return；
}
函數(shù)的參數(shù)填void,表示函數(shù)不需要參數(shù)或者讓參數(shù)列表空著
int fun(void)
{
//函數(shù)體代碼
}
函數(shù)的參數(shù)用void*，表示接受任意數(shù)據類型的指針

注意：

不能用void聲明變量，他不能代表一個真實的變量

不能對void*指針解引用（需要轉換成其他類型的指針）

把其它類型的指針賦值給void*指針不需要轉換

解引用的時候需要知道書局占用內存空間的大小

沒有使用void*的時候會出現(xiàn)"燙燙燙燙燙"

使用void*解決上邊問題

另一種方法: 寫一個函數(shù)來實現(xiàn):函數(shù)有兩個形參:一個變量名,另外一個存地址,不需要返回值

#include <iostream>

using namespace std;

//聲明函數(shù)
void func(string varname, int* p);  //如果將int*型指針改為void*指針不需要在調用函數(shù)是進行強制轉換

int main()
{
	//顯示變量十六進制地址
	int a;
	char b;
	cout << "a的地址是:" << &a << endl;
	cout << "b的地址是:" << &b << endl;

	//函數(shù)調用
	func("a", &a);
	//func("b", &b);//報錯 不能將字符指針轉換成整形指針
	func("b", (int*)&b);  //需要將字符指針轉換成整形指針

	/*cout << "a的地址是:" << (void*)&a << endl;
	cout << "b的地址是:" << (void*)&b << endl;*/
}

//函數(shù)定義
void func(string varname, int* p)
{
	cout << varname << "地址是:" << p << endl;
}

6、C++內存模型

內存空間：從地址從低到高：代碼段（存放程序中的二進制代碼）、數(shù)據段（存放全局變量、靜態(tài)變量）、堆（由程序員管理,需要手動 new malloc delete free 進行分配和回收，空間較大，可能會出現(xiàn)內存泄漏和空閑碎片的情況、堆是向上增長）、棧（由編譯器管理分配和回收，存放局部變量和函數(shù)參數(shù)、棧是向下增長）

棧和堆的區(qū)別：

1、管理方式不同：棧是需要系統(tǒng)管理分配和回收；堆則需要程序員手動new malloc delete free 分配和回收

2、空間大小不同:堆內存空間大小受限于物理內存空間（內存越大，分配的空間就越多）；而棧的就特別小，一般只有8M（修改系統(tǒng)參數(shù)可以修改棧的大小）

3、分配方式不同：堆是動態(tài)分配；棧有動態(tài)分配和靜態(tài)分配

4、分配效率不同：棧是系統(tǒng)提供的數(shù)據結構，計算機在底層提供了對棧的支持，進棧和出棧有專門指令，效率比較；堆是由C++函數(shù)庫提供

7、動態(tài)分配內存 new 和 delete

//動態(tài)分配內存的步驟
//1.聲明一個指針
// 2.用new運算符想系統(tǒng)申請一塊內存,讓指針指向這塊內存
// 3.通過指針解引用方法,像使用變量一樣使用這塊內存
// 4.如果這塊內存不用了,用delete運算符釋放這塊內存
// 申請內存的語法:new 數(shù)據類型(初始值) // c++11
// 釋放內存語法:delete 地址;
#include <iostream>  //包含頭文件
using namespace std;  //指定缺省的命名空間

int main()  //程序的入口
{
	//動態(tài)分配內存的步驟
	//1.聲明一個指針
	int* p;
	// 2.用new運算符想系統(tǒng)申請一塊內存,讓指針指向這塊內存
	p = new int(5);
	// 3.通過指針解引用方法,像使用變量一樣使用這塊內存
	cout << "*p=" << *p << endl;
	*p = 8;  //解引用
	cout << "*p=" << *p << endl;
	// 4.如果這塊內存不用了,用delete運算符釋放這塊內存
	delete p;

	// 申請內存的語法:new 數(shù)據類型(初始值)  //	c++11
	// 釋放內存語法:delete 地址;

	return 0;
}
注意：

1、如果動態(tài)分配內存不用了，必須要用delete釋放，否則有可能用盡系統(tǒng)的內存；

2、動態(tài)分配的內存生命周期與程序相同，程序退出時，如果沒有釋放，系統(tǒng)將自動回收

8、二級指針

指針是指針變量的簡稱，也是變量，是變量就有地址

指針用于存放普通變量的地址

二級指針用于存放指針變量的地址

聲明二級指針的語法：數(shù)據類型** 指針名；

使用指針有兩個目的：（1）傳遞地址；（2）存放動態(tài)分配的內存地址。

在函數(shù)中，如果傳遞普通變量的地址，形參用指針；傳遞指針的地址的地址，形參用二級指針；
#include <iostream>  //包含頭文件
using namespace std; //指定缺省的命名空間

int main()
{
	//先聲明一個普通變量i;
	int i;
	//變量初始化賦值為8
	i = 8;
	//顯示這個變量的值和地址
	cout << "i的值=" << i << endl;
	cout << "i的地址是:" << &i << endl;
	cout << endl;

	//在聲明一個指針pi,讓它指向變量i
	int* pi = &i;
	cout << "pi的值=" << pi << endl;
	cout << "pi的地址是:" << &pi << endl;
	//解引用的結果
	cout << "*pi的值=" << *pi << endl;
	cout << endl;

	//聲明二級指針
	int** ppi = &pi;
	cout << "ppi的值=" << ppi << endl;
	cout << "ppi的地址是:" << &ppi << endl;
	cout << "*ppi的值=" << *ppi << endl;
	cout << endl;
	cout << "**pi的值=" << **ppi << endl;
}

9.空指針

在C和C++中,用0或者NULL都可以表示空指針

聲明指針后,在賦值之前,讓它指向空,表示沒有指向任何地址.

1、使用空指針的后果

如果對空指針解引用，程序會崩潰。

如果對空指針使用delete運算符，系統(tǒng)將忽略該操作，不會出現(xiàn)異常。所以內存釋放后，也應該把指針指向空。

使用空指針方式定義函數(shù)就會導致程序蹦崩潰

#include <iostream>  //包含頭文件
using namespace std;  //指定缺省的命名空間

//函數(shù)聲明
void func(int* no, string* str);

int main()
{
	////聲明編號
	//int bh = 3;
	////聲明信息
	//string message = "我是C++程序員";
	////函數(shù)調用
	//func(&bh, &message);

	/**使用指針方式**/

	//使用空指針聲明編號
	int* bh = 0; /*new int(3);*/
	//使用空指針聲明信息
	string* message = 0; /*new string("杭州智諾科技");*/

	//函數(shù)調用
	func(bh, message);

	//釋放內存
	delete bh;
	delete message;
}

//函數(shù)定義
void func(int* no, string* str)
{
	cout << "你好" << *str << "我是" << *no << "號" << "韋廣豪" << endl;  //程序崩潰的原因:因為使用空指針,解引用就成了非法操作
}

問題解決方法:在定義函數(shù)中增加判斷代碼,如果形參是空指針,就返回不要繼續(xù)執(zhí)行下面的流程

#include <iostream>  //包含頭文件
using namespace std;  //指定缺省的命名空間

//函數(shù)聲明
void func(int* no, string* str);

int main()
{
	////聲明編號
	//int bh = 3;
	////聲明信息
	//string message = "我是C++程序員";
	////函數(shù)調用
	//func(&bh, &message);

	/**使用指針方式**/

	//使用空指針聲明編號
	int* bh = 0; /*new int(3);*/
	//使用空指針聲明信息
	string* message = 0; /*new string("杭州智諾科技");*/

	//函數(shù)調用
	func(bh, message);

	//釋放內存
	delete bh;
	delete message;
}

//函數(shù)定義
void func(int* no, string* str)
{
 //判斷形參是否為空指針的代碼
	if ((no==0) || (str==0))
	{
		return;
	}
 //目的:保證代碼的健壯性

	cout << "你好" << *str << "我是" << *no << "號" << "韋廣豪" << endl;
}

解決程序崩潰問題,但是沒有顯示任何內容;

C++11的 nullptr

C++11建議使用nullptr表示空指針,也就是(void*)0

10.野指針

野指針:就是指針指向的不是一個有效的地址;

報錯原因:不能將十六進制數(shù)轉換為指針

解決辦法:強制類型轉換(但是會地址顯示沒問題,但是解引用失敗程序崩潰)

在程序中,如果訪問野指針,可能會造成程序崩潰

出現(xiàn)野指針的情況主要有三種:

1、指針在定義的時候，如果沒有進行初始化，它的值是不確定的

(也就是說指針在沒有初始化之前編譯器不讓使用該指針)

2、如果用指針指向了動態(tài)分配的內存，內存被釋放后，指針不會置空，但是指向地址已失效
#include <iostream>  //包含的頭文件
using namespace std;  //指定缺省的命名空間

int main()
{
	//聲明一個指針并分配一塊內存空間
	int* p;
	p = new int(3);

	//顯示指針值和對p解引用的結果
	cout << "p=" << p << endl;
	cout << "*p=" << *p << endl;

	delete p;

	cout << "p=" << p << endl;
	cout << "*p=" << *p << endl;
}
(解釋:釋放內存,程序崩潰)

3、指針指向的變量已超越變量的作用域（變量的內存空間已被系統(tǒng)回收）
#include <iostream>  //包含的頭文件
using namespace std;  //指定缺省的命名空間

//聲明函數(shù)
int* func();

int main()
{
	//聲明一個指針
	int* p;
	//函數(shù)調用
	func();

	//將函數(shù)func復制給指針p
	p = func();  //相當于 int*p=func();

	//顯示指針值和對p解引用的結果
	cout << "p=" << p << endl;
	cout << "*p=" << *p << endl;
}

//函數(shù)的定義
int* func()
{
	//定義一個變量
	int a = 3;
	//顯示結果
	cout << "a=" << a << endl;
	cout << "a的地址是:" << &a << endl;

	return &a;
}
避免出現(xiàn)野指針的方法：

1、在定義的時候，如果沒地方指，就初始化為nullptr。

2、動態(tài)分配的內存被釋放后，將其置為nullptr。

3、函數(shù)不要返回局部變量的地址。

11、函數(shù)指針和回調函數(shù)

函數(shù)指針：

函數(shù)的二進制代碼存放在內存區(qū)四區(qū)中的代碼段，函數(shù)的地址它在內存中的開始地址。如果把函數(shù)的地址作為參數(shù)，就可以在函數(shù)中靈活調用其他函數(shù)。

使用函數(shù)指針的三個步驟：

1、聲明函數(shù)指針；

聲明普通指針時，必須提供指針的類型。同樣聲明函數(shù)指針時，也必須提供函數(shù)類型，函數(shù)類型是指返回值和參數(shù)列表

#include<iostream>  //包含的頭文件
using namespace std;  //指定缺省的命名空間

//聲明函數(shù)指針
void (*pfunc)(int, string);

//普通函數(shù)聲明
void func(int no, string str);

int main()
{
	int bh = 3;
	string message = "C++開發(fā)者";

	//普通函數(shù)的函數(shù)調用
	func(bh, message);

	//對函數(shù)指針賦值
	pfunc = func;  //語法 : 函數(shù)指針名=函數(shù)名;
	//使用函數(shù)指針名調用函數(shù)
	pfunc(bh, message);
}

//普通函數(shù)的定義
void func(int no, string str)
{
	cout << "你好" << no << "號:" << str << endl;
}

2、讓函數(shù)指針指向函數(shù)的地址；

3、通過函數(shù)指針調用函數(shù)。

//對函數(shù)指針賦值
	pfunc = func;  //語法 : 函數(shù)指針名=函數(shù)名;
	//使用函數(shù)指針名調用函數(shù)
	pfunc(bh, message);

普通函數(shù)的調用方式:

#include <iostream>  //包含的頭文件

using namespace std;  //指定缺省的命名空間

//聲明函數(shù)
void func(int no, string str);

int main()
{
	//聲明編號
	int bh = 3;
	//聲明信息
	string message = "我是C++開發(fā)者";

	//函數(shù)調用
	func(bh, message);
}

//函數(shù)定義
void func(int no, string str)
{
	cout << "你好" << no << "號" << str << endl;
}

回調函數(shù):

#include <iostream>  //包含的頭文件

using namespace std;  //指定缺省的命名空間

void 個性化表白函數(shù)()
{
	//個性化表白的代碼
}

void 表白神器(個性化表白函數(shù)指針p)
{
	個性化表白函數(shù)指針p();
}

int main()
{
	表白神器(個性化表白函數(shù)名);
}

代碼填充

//函數(shù)的回調
#include <iostream>  //包含的頭文件

using namespace std;  //指定缺省的命名空間
//回調函數(shù)1
void func1()  //個性化表白函數(shù)
{
	cout << "我是C++開發(fā)" << endl;
}
//回調函數(shù)2
void func2()
{
	cout << "我是C開發(fā)者" << endl;
}
//調用者函數(shù)
void show(void(*pf)())
{
	//工作前的準備
	cout << "工作前準備已經完成" << endl;
	//用函數(shù)指針名調用個性化表白函數(shù)
	pf();
	//尾工作
	cout << "收尾工作已完成" << endl;
}

int main()
{
	//調用功能函數(shù)
	show(func1);
}

12、一維數(shù)組

數(shù)組是一組數(shù)據類型相同的變量,可以存放一組數(shù)據。

1、創(chuàng)建數(shù)組

聲明數(shù)組的語法：數(shù)據類型數(shù)組名[數(shù)組長度]

#include <iostream>  //包含的頭文件

using namespace std;  //指定缺省的命名空間

int main()
{
	//創(chuàng)建數(shù)組
	int bh[3];  //編號
	string name[3]; //姓名

	//可以通過數(shù)組下表訪問數(shù)組元素,數(shù)組下標從0開始.
	//數(shù)組中的每個元素特征和使用方法與單個變量完全相同

	bh[0] = 3; //第0個
	bh[1] = 5; //第1個
	bh[2] = 8; //第2個

	cout << "bh[0]=" << bh[0] << endl;
	cout << "bh[1]=" << bh[1] << endl;
	cout << "bh[2]=" << bh[2] << endl;

	cout << endl;

	//可以使用變量來創(chuàng)建數(shù)組
	//創(chuàng)建變量i
	int i;
	//將i賦值為 表示第0個
	i = 0;
	//將數(shù)組下標用變量表示
	bh[i] = 3;

	//將i賦值為1  表示第1個
	i = 1;
	//將數(shù)組下標用變量表示
	bh[i] = 5;

	//將i賦值為2  表示第2個
	i = 2;
	bh[i] = 8;

	i = 0;
	cout << "bh[0]=" << bh[i] << endl;
	i = 1;
	cout << "bh[1]=" << bh[i] << endl;
	i = 2;
	cout << "bh[2]=" << bh[i] << endl;
}

注意：數(shù)組長度必須是整數(shù)，可以是常量，也可以是變量和表達式

處理數(shù)組的常用方法:使用循序:for循環(huán)和while循環(huán)都可以

#include <iostream>  //包含的頭文件

using namespace std;  //指定缺省的命名空間

int main()
{
	//創(chuàng)建數(shù)組
	int bh[3];  //編號
	string name[3]; //姓名

	//可以通過數(shù)組下表訪問數(shù)組元素,數(shù)組下標從0開始.
	//數(shù)組中的每個元素特征和使用方法與單個變量完全相同

	for (int i = 0; i < 3; i++)  //i要小于數(shù)組長度
	{
		bh[i] = 30 + i;  //循環(huán)第0次,i的值是0,編號是30  循環(huán)第1次,i的值是1 編號是31 循環(huán)第二次,i的值是2 編號是32
	}
	int i;

	i = 0;
	cout << "bh[0]=" << bh[i] << endl;
	i = 1;
	cout << "bh[1]=" << bh[i] << endl;
	i = 2;
	cout << "bh[2]=" << bh[i] << endl;
}

將上述代碼繼續(xù)優(yōu)化

#include <iostream>  //包含的頭文件

using namespace std;  //指定缺省的命名空間

int main()
{
	//創(chuàng)建數(shù)組
	int bh[3];  //編號
	string name[3]; //姓名

	//可以通過數(shù)組下表訪問數(shù)組元素,數(shù)組下標從0開始.
	//數(shù)組中的每個元素特征和使用方法與單個變量完全相同

	for (int i = 0; i < 3; i++)  //i要小于數(shù)組長度
	{
		bh[i] = 30 + i;  //循環(huán)第0次,i的值是0,編號是30  循環(huán)第1次,i的值是1 編號是31 循環(huán)第二次,i的值是2 編號是32
	}
	/*int i;

	i = 0;
	cout << "bh[0]=" << bh[i] << endl;
	i = 1;
	cout << "bh[1]=" << bh[i] << endl;
	i = 2;
	cout << "bh[2]=" << bh[i] << endl;*/
	//使用for循環(huán)改寫
	for (int i = 0; i < 3; i++)
	{
		cout << "bh[" << i << "]=" << bh[i] << endl;
	}
}

2、數(shù)組的使用

可以通過下標訪問數(shù)組中的元素,數(shù)組下標從0開始

數(shù)組中每個元素的特征和使用方法與單個變量完全相同

語法:數(shù)組名[數(shù)組下標]

3、數(shù)組占用內存的情況

用sizeof（數(shù)組名）可以得到整個數(shù)組占用內存空間的大小（只適用于C++基本數(shù)據類型）

#include <iostream>  //包含的頭文件

using namespace std;  //指定缺省的命名空間

int main()
{
	//創(chuàng)建數(shù)組
	int bh[3];  //編號
	string name[3]; //姓名

	cout << "數(shù)組bh占用的內存空間是:" << sizeof(bh) << endl;

}

4、數(shù)組的初始化

聲明的時候初始化

數(shù)據類型數(shù)組名[數(shù)組長度] ={值1，值2, ......}

數(shù)據類型數(shù)組名[] ={值1，值2，.......}

數(shù)據類型數(shù)組名[數(shù)組長度] = {0}；//把全部元素初始化為0

數(shù)據類型數(shù)組名[數(shù)組長度] = { }；//把全部元素初始化為0

13、一維數(shù)組的越界

#include <iostream>

using namespace std;

int main()
{
	//定義一維數(shù)組
	int a[5] = { 3,6,9,5,8 };

	//用數(shù)組表示法操作數(shù)組
	/*cout << "a[0]的值是:" << a[0] << endl;
	cout << "a[1]的值是:" << a[1] << endl;
	cout << "a[2]的值是:" << a[2] << endl;
	cout << "a[3]的值是:" << a[3] << endl;
	cout << "a[4]的值是:" << a[4] << endl;*/
	//使用for循環(huán)優(yōu)化代碼
	for (int i = 0; i < 5; i++)
	{
		cout << "a[" << i << "]的值是:" << a[i] << endl;
	}
	cout << endl;

	//用指針表示法操作數(shù)組
	int* p = a;
	/*cout << "*(p+0)的值是:" << *(p + 0) << endl;
	cout << "*(p+1)的值是:" << *(p + 1) << endl;
	cout << "*(p+2)的值是:" << *(p + 2) << endl;
	cout << "*(p+3)的值是:" << *(p + 3) << endl;
	cout << "*(p+4)的值是:" << *(p + 4) << endl;*/
	//使用for循環(huán)優(yōu)化代碼
	for (int i = 0; i < 5; i++)
	{
		cout << "*(p+" << i << ")的值是:" << *(p + i) << endl;
	}
}

14、解釋器和編譯器有什么不同？

解釋器：解釋器一種對代碼（或者字節(jié)碼）進行解釋并執(zhí)行相應的操作的工具；編譯器將代碼作為輸入，并生成目標文件。就C++而言，編譯和鏈接后，將得到一個可執(zhí)行文件，處理器可直接執(zhí)行它，而無需做進一步解釋

編譯器：將C++代碼文件作為輸入，并生成一個使用機器語言的目標文件。通常代碼依賴與庫和其他代碼文件中的函數(shù)。

15、鏈接器的作用

將編譯器生成的目標文件和庫文件鏈接在一起，生成最終的可執(zhí)行文件或者共享庫

16、正常的開發(fā)周期包括哪些步驟

編寫代碼-->通過編譯創(chuàng)建目標文件-->通過鏈接創(chuàng)建可執(zhí)行文件-->執(zhí)行應用程序一邊進行測試-->調試-->修復代碼中的錯誤并重復這些步驟

17、一維數(shù)組的排序

//1.如果函數(shù)的返回值<0, 那么p1所指向元素的會被排在p2所指向元素的前面
//2.如果函數(shù)的返回值==0, 那么p1所指向的元素與p2所指向的元素的順序不確定
//3.如果函數(shù)的返回值>0, 那么p1所指向的元素會被排在p2所指向元素的后面

//qsort()函數(shù)用于各種數(shù)據類型的數(shù)組進行排序
//函數(shù)的原型:
// void qsort(voidbase,size_t number,size_t size,int(compar)(const void ,const void));

#include <iostream> //包含頭文件

using namespace std;  //指定缺省的命名空間

//1.如果函數(shù)的返回值<0, 那么p1所指向元素的會被排在p2所指向元素的前面
//2.如果函數(shù)的返回值==0, 那么p1所指向的元素與p2所指向的元素的順序不確定
//3.如果函數(shù)的返回值>0,  那么p1所指向的元素會被排在p2所指向元素的后面

//qsort()函數(shù)用于各種數(shù)據類型的數(shù)組進行排序
	//函數(shù)的原型:
	// void qsort(void*base,size_t number,size_t size,int(*compar)(const void *,const void*));

//聲明回調函數(shù)
int compasc(const void* p1, const void* p2);

int main()
{
	//聲明一個整i型數(shù)組
	int a[8] = { 4,2,7,5,8,6,1,3 };

	//函數(shù)的原型:
	// void qsort(void*base,size_t number,size_t size,int(*compar)(const void *,const void*));
	//回調函數(shù)的調用
	qsort(a, sizeof(a) / sizeof(int), sizeof(int), compasc);

	//顯示數(shù)組內容
	for (int i = 0; i < 8; i++)
	{
		//cout << "a[" << i << "]的值是: " << *(a + i) << endl;
		cout << "a[" << i << "]的值是: " << a[i] << endl;
	}

	return 0;
}

//回調函數(shù)的定義:即回調函數(shù)實現(xiàn)過程
int compasc(const void* p1, const void* p2)
{
	/*if (*((int*)p1) < *(int*)p2)
		return -1;
	if (*(int*)p1 == *(int*)p2)
		return 0;
	if (*(int*)p1 > *(int*)p2)
		return 1;*/
	return *((int*)p1) - *((int*)p2);  //等同于邊代碼
}

刷新頁面返回頂部

編程成長之路

公告