柚子快報邀請碼778899分享：c++基礎(chǔ)
柚子快報邀請碼778899分享：c++基礎(chǔ)
C++基礎(chǔ)
1：頭文件
1.0：頭文件：其中有帶h和沒有帶h后綴的，帶h后綴的是老版本的編譯器，沒帶是新版本的編譯器。
#include
#include
#define _CRT_SECURE_NO_WARNINGS
#include
1.1：頭文件iostream：如果程序使用輸入或輸出工具，一定要提供下面這兩行代碼：
#include
using namespace std;
iostream是C++標準庫中的一個頭文件
提供了輸入輸出流的支持，包括了cin、cout、cerr、clog等對象以及相應(yīng)的操作符<<和>>等。通過引入iostream頭文件，可以使用C++中的輸入輸出流機制，使得程序的輸入輸出更加方便、靈活，也更符合面向?qū)ο蟮木幊趟枷??？梢酝ㄟ^以下代碼引入iostream頭文件：
#include
在程序中使用cout輸出信息的示例：
#include
using namespace std;
int main() {
cout << "Hello World!" << endl;
return 0;
}
其中，cout代表標準輸出流，<<代表插入操作，將數(shù)據(jù)流插入到輸出流中，endl代表換行操作。以上程序會輸出一行字符串"Hello World!"。
#include
1.2：問題解答
1.21：為什么將iostream文件的內(nèi)容添加到程序中？
答：涉及到程序與外部世界之間的通信，iostream中的io指的就是輸入（進入程序的信息）和輸出（從程序中發(fā)出的信息）
解釋：c++中輸入和輸出方案，涉及iostream文件中的多個定義，為了使用cout來顯示消息，第一個程序需要這些定義，include編譯指令導(dǎo)致iostream文件的內(nèi)容一起被發(fā)送給編譯器，iostream中的內(nèi)容沒有被修改，而是將源代碼文件和iostream組合成一個符合文件，編譯的下一階段
1.22：using namespace std有什么作用：
在 C++ 中，using namespace std; 是一個編譯指令，用來告訴編譯器在代碼中使用 std 命名空間中的標識符時不需要加上前綴 std::，直接使用即可。
例如，如果不使用 using namespace std;，則需要使用 std::cout 來輸出內(nèi)容：
#include
int main() {
std::cout << "Hello, world!" << std::endl;
return 0;
}
而使用 using namespace std; 后，則可以直接使用 cout：
#include
using namespace std;
int main() {
cout << "Hello, world!" << endl;
return 0;
}
需要注意的是，對于大型項目或者需要避免命名沖突的情況，建議不要在頭文件中使用 using namespace std;，而是在源文件中使用。同時，其他命名空間中的標識符也應(yīng)該使用對應(yīng)的命名空間前綴來調(diào)用。
1.3：函數(shù)解析：
using ：叫做編譯指令，名稱空間，在編譯器執(zhí)行編譯的時候，不知道是那個版本的，名稱空間的名稱用來指哪個版本的產(chǎn)品，按照這種方式，類，函數(shù)，變量便是c++編譯器的標準組件，現(xiàn)在都被放置在名稱空間的std中。僅當頭文件沒有擴展名h時，情況才如此。意味著，在iostream中定義用于輸出的cout變量上是：std::cout，endl是std::endl，可以省略編譯指令using，以下述方式進行編碼。
cin：輸入符
cout：輸出符：默認是以10進制格式顯示整數(shù)的
cout.put()：輸出符：通過類對象cout來使用函數(shù)put(),是另一種顯示字符的方法，可以代替<<運算符.
endl：控制符，在輸出流中插入endl將屏幕光標移到下一行，
\n：換行符：通常在字符串中運用，顯示字符串時，字符串包含了換行符，而不是在末尾加endl，可以減少輸出量
int carrots：變量：首先用int，確定數(shù)據(jù)類型，carrots：為變量，在c++中變量都必須聲明。
2：函數(shù)：函數(shù)分為兩種，有返回值的和沒有返回值的，
1：平方根函數(shù)：sqrt()要定義頭文件，平方根的頭文件為：include
#include
using namespace std;
#include
int main() {
//變量的定義
//語法：數(shù)據(jù)類型 變量名 = 初始值
int carrots;
cout << "hew many" << endl;
cin >> carrots;
carrots = carrots + 1;
cout << "now you" << carrots << endl;
//平方根的返回值數(shù)據(jù)類型定義
double area;
double side;
//輸入
cin >> area;
//使用sqrt函數(shù)
side = sqrt(area);
//輸出
cout << side << endl;
//結(jié)束返回值
return 0;
}
LNK開頭的是連接錯誤
3：數(shù)值類型
int類型最大最小值
INT_MIN :最小值
INT_MAX ：最大值
unsigned int 類型最大是：
UINT_MAX
long類型的最大最小
LONG_MIN
LONG_MAX
無符號的long類型大小
ULONG_MAX
long long 類型大小
LLONG_MIN
LLONG_MAX
無符號類型
ULLONG_MAX
整型：short，int，long，long long，這些整型是從小到大進行排序的。
存儲值： short：至少16位 int：int至少與short一樣長 long：至少32為，且至少與int一樣長 long long：至少64位，且至少與long一樣長 無符號整型：就是值不能為負數(shù)，整型前面加上unsigned如：unsigned short等等.
輸出符，進制的修改 cout：輸出符：默認是以10進制格式顯示整數(shù)的 使用控制符可以修改輸出cout函數(shù)的進制，控制符為：dec：修改十進制，hex：修改十六進制，oct：修改八進制 cout默認是以10進制格式顯示整數(shù)的，改成十六進制的，代碼如下
cout << hex;
cout << 十六進制的變量 << endl;
char類型：字符和小整數(shù)，足夠長，能夠表示目標計算機系統(tǒng)中的所有基本符號，所有的字母，數(shù)字，標點符號等,c++將常量存儲為char類型
常量函數(shù)：const，讓數(shù)值固定死。
浮點數(shù)類型：float，double，long double，在默認情況下是雙進度的：double類型
float：至少32位 double：至少48位 long double：為80，96，或128
定點模式：寫入到函數(shù)體中，cout.setf(ios_base::fixed,ios_base::floatfield);精確顯示如是float，精度到后面的6位
數(shù)組
創(chuàng)建一個數(shù)組 數(shù)組的類型 數(shù)組的變量[ 多少個數(shù)組] 創(chuàng)建數(shù)組及賦值 int 變量[3] = {3個自定義元素}
不可以這樣賦值，如下列： int hend[4] = {5,6,7,8};：定義完成 hand = heand ：不能定義后，在進行賦值。 hend[4] = {5,6,8,9}：也不能定義以后在fu
顯示類型的內(nèi)存大小函數(shù)
sizeof("%對應(yīng)的占位符號"，&對應(yīng)的變量)
計算數(shù)組里面多少個元素
列如：short things[] = {1,5,3,8};
int num_elememts = sizeof things / sizeof (short);
數(shù)組的初始化
如： unsigned int counts[10] = {}; 全部初始化為0。 float balances[100] {}; 全部初始化為0。
數(shù)組初始化禁止縮窄轉(zhuǎn)換，要類型一樣的。
如：long plifs[] = {25,92,3.0};這里的3.0是浮點數(shù)，轉(zhuǎn)換成整數(shù)是要縮窄轉(zhuǎn)換的，即使浮點數(shù)后面小數(shù)點為0，也不能通過編譯。
字符串
字符 : ’ '(單引號是一個字符，如果要賦值成數(shù)組后面要加上 /0 其中 /0 為空字符)，
字符串： " "(雙引號是一個字符串是默認帶 /0 的)：其實雙引號代表著的是一個地址。
strlen：字符串的有效長度，這里是指，，如果設(shè)置為15個長度數(shù)組，但是只用到了4個有效數(shù)組這個函數(shù)就只返回4個字節(jié)
strlen(字符串變量)
字符串復(fù)制：strcpy(變量1，變量2):對變量復(fù)制
字符串的拼接：strcat()：字符串的拼接
struct inflatable：結(jié)構(gòu)體
struct inflatable
{
char name[20];
float volume;
double price;
}
創(chuàng)建枚舉量，枚舉賦值必須是整型，int或long或long long
enum spectrum{red,orange,yellow,green,blue,violet,indigo,ultraviolet};
括號內(nèi)的是枚舉量
spectrum ：枚舉類
spectrum band; ：通過枚舉類創(chuàng)建枚舉變量
枚舉的取值范圍如下，首先， 要找到上限，需要知道枚舉的最大值，找到小于這個最大值的，最小的2的冪，將它減去1，得到的便是取值范圍的上限。 要找到下限：需要知道枚舉量的最小值，如果它不小于0，則取值范圍的下限為0，否則采用與尋找上限方式相同的方式，但加上負號，列如，如果最小的枚舉量為-6，而比他小的，最大的2的冪是-8，因此下限為-7 上限： 下限：
4：指針
C++中的指針是一種特殊的數(shù)據(jù)類型，它存儲了一個變量的內(nèi)存地址。通過指針，程序可以對變量的值和地址進行操作，使得程序具有更高的靈活性和效率。
在C++中，定義一個指針需要使用 * 符號。例如：
int* ptr;
上述代碼定義了一個整型指針 ptr。
指針可以通過取地址符 & 來獲取變量的地址，例如：
int num = 10;
int* ptr = #
上述代碼定義了一個整型變量 num，并且通過指針變量 ptr 獲取了 num 的地址。此時，ptr 存儲的值就是 num 的地址。
指針可以通過解引用符 * 來獲取指針所指向的變量的值，例如：
int num = 10;
int* ptr = #
cout << *ptr; // 輸出：10
上述代碼通過解引用符 * 獲取了 ptr 所指向的 num 變量的值，即輸出了 10。
指針還可以用于動態(tài)內(nèi)存分配，例如：
int* arr = new int[10]; // 動態(tài)分配長度為 10 的整型數(shù)組
上述代碼使用了 new 操作符動態(tài)分配了一個長度為 10 的整型數(shù)組，并將數(shù)組的首地址賦給了指針變量 arr。此時，arr 就可以像普通數(shù)組一樣使用。
需要注意的是，指針也可以為空，表示指向的地址為 NULL。在使用指針時需要注意空指針的情況。
指針：int* p_updates：創(chuàng)建一個int*類型的p_updates指針，帶 int*符號的就是創(chuàng)建int類型的指針
&updates：前面帶個&符號在寫上變量名：打印出來的是內(nèi)存地址
p_updates = &updates：將內(nèi)存地址賦值到指針變量中
*p_updates ：打印出來的是&updates地址里面的值。
5：new用法
在C++中，new是一個操作符，用于在堆上動態(tài)分配內(nèi)存空間。它的基本語法為：
指針變量 = new 數(shù)據(jù)類型;
其中，指針變量是一個指向已分配內(nèi)存空間的指針，數(shù)據(jù)類型是要分配的數(shù)據(jù)類型。
例如，如果想動態(tài)分配一個整型變量，可以使用以下語句：
int *p = new int;
這樣就在堆上動態(tài)分配了一個int型變量，并將其地址賦給了指針變量p。
另外，new操作符還可以用于動態(tài)分配數(shù)組。例如，如果想動態(tài)分配一個大小為10的整型數(shù)組，可以使用以下語句：
int *p = new int[10];
這樣就在堆上動態(tài)分配了一個大小為10的int型數(shù)組，并將其首元素的地址賦給了指針變量p。
使用完new分配的內(nèi)存后，應(yīng)該使用delete操作符來釋放這些內(nèi)存，避免內(nèi)存泄漏。delete的使用方法為：
delete 指針變量;
例如，如果要釋放前面所分配的整型變量內(nèi)存，可以使用以下語句：
delete p;
如果要釋放前面所分配的整型數(shù)組內(nèi)存，可以使用以下語句：
delete [] p;
使用new來動態(tài)的分配內(nèi)存的操作符：是分配的內(nèi)存塊，
new可以在運行時動態(tài)地申請內(nèi)存來構(gòu)造一個對象或一組對象，這些對象的生命周期由程序員控制。 當使用new時一定要使用下面的釋放內(nèi)存的delete，否則會內(nèi)存泄漏。
new 數(shù)據(jù)類型;
new 數(shù)據(jù)類型[數(shù)組大小];
typeName * pointer_name = new typeName ;
釋放掉new開辟的內(nèi)存空間delete
delete 內(nèi)存塊的指針； 釋放的是指針指向的內(nèi)存，不是刪除指針本身。
在C++中，使用new動態(tài)地分配內(nèi)存空間，程序員需要手動釋放這些內(nèi)存空間以避免內(nèi)存泄漏?？梢允褂胐elete表達式來釋放由new運算符開辟的內(nèi)存空間。
delete有兩種形式，一種是釋放單個對象的內(nèi)存，另一種是釋放一個對象數(shù)組的內(nèi)存。具體用法如下： 例如： 1：釋放單個對象的內(nèi)存：
int* ptr = new int; //分配一個int類型的內(nèi)存空間
*ptr = 10; //給這個內(nèi)存空間賦值
delete ptr; //釋放這個內(nèi)存空間
2：釋放一個對象數(shù)組的內(nèi)存：
// 分配內(nèi)存
int* arr = new int[10];
// 使用內(nèi)存
// ...
// 釋放內(nèi)存
delete[] arr;
當delete表達式執(zhí)行時，它會先調(diào)用該空間中的析構(gòu)函數(shù)，然后將空間返回給操作系統(tǒng)。如果指針不是通過new分配的，則不能使用delete來釋放它，否則會導(dǎo)致未定義的行為。
6：
窗口一直執(zhí)行
system("pause");
代碼塊，方法
定義方法
void test()
輸入阻塞函數(shù)
scanf("%hd",&變量)
&變量：取變量的地址
從鍵盤上輸入給變量賦值：cin，getline()
輸入頭文件 ：#include
cin >> 變量 :這個面向字符讀取，如果遇到空格或者換行符的話就會終止
cin.getline() ：輸入的字符要比指定的字符多就會getline和get將把剩余的字符留到輸入的列表中，而getline()會設(shè)置失效位
cin.getline() 這個面向行讀取，遇到空格也不會終止
這里getline():有兩個函數(shù)，第一個是字符的變量，第二個是字符變量的上限
cin.get()：get()：在讀取空行會后將設(shè)置失效位
cin.get() 也有兩個參數(shù) ，第一個是字符的變量，第二個是字符變量的上限 ，面向行的輸入，但是還有一個換行符，在緩存區(qū)里面 再使用使用cin.get：就可以在換行符進行了捕獲了
可以連續(xù)使用cin.getline().getline()：getline()括號內(nèi)寫上，變量和字符的上限值，但是get()的是不行的，因為第一個get讀取了緩存區(qū)的字符，但是回車換行符還再緩存區(qū)中當，連續(xù)再點get時讀的是回車換行符，緩存區(qū)就失效
如果失效了，在進行開啟捕獲位的話使用cin.clear()；
創(chuàng)建結(jié)構(gòu)體：struct 變量 {}
輸出函數(shù)
printf()
顯示類型的內(nèi)存大小函數(shù)
sizeof("%對應(yīng)的占位符號"，&對應(yīng)的變量)
sizeof 變量名
類型
數(shù)據(jù)類型不一樣，首先轉(zhuǎn)換成一樣的類型再進行計算
unsigned :無符號類型也就是不為負數(shù)，最小值為0
無符號是u%打印
代表著10進制無符號
字符語法
char
占位符為%c
內(nèi)存大小為1個字節(jié)
字符存儲的時候存儲的是一個數(shù)字這里有一個ascii碼表，每個字符都對應(yīng)著數(shù)字對字符代表著
字符串
char[] = "";
增加頭文件
#include
string 變量名 = ""; :`string` :能自動調(diào)節(jié)所需的內(nèi)存大小
布爾數(shù)據(jù)類型
bool
bool 變量名= true; 真
bool 變量名 = false; 假
所存空間為1
short ：有符號的類型，最大到了32768多左右 ,短整型
占位符號： %hd\n
unsigned short ：無符號
占位符號： %hu\n
內(nèi)存占2個字節(jié)
int ：數(shù)值類型 ，整型，
unsigned int ：無符號的整型
占位符號：用%d
內(nèi)存大小為4個字符
long ：長整型
unsigned long ：無符號的長整型
占位符號：用%ld
內(nèi)存大小為 4或者8，在gcc編譯器中確定就是占用8個字符，32位的4個字節(jié)，64位的8個字節(jié)
long long
unsigned long long :無符號long類型
占位符號為%lld
內(nèi)存大小為8個字符
float :浮點型
精確到6位
占用4個字節(jié)
double 小數(shù)雙精度
精確到15位
內(nèi)存占用8個字節(jié)
字符常量： '' ,單引號
字符串常量: "" ，雙引號
宏常量： #define 變量名 定義上方
修飾變量（也稱為常量）： const
\t ：中間形成個空格，形成對其方式
字符轉(zhuǎn)換
toupper() :將字符轉(zhuǎn)換成大寫
tolower() :將字符轉(zhuǎn)換成小寫
toascii() :將字符轉(zhuǎn)換成ascii 碼
進制轉(zhuǎn)換
十進制：逢十進一，0-9 ，正常以數(shù)字1-9開頭 ，%d ：源碼占位 二進制：逢二進一，0-1 ，c語言不能直接行書寫2進制進 八進制：逢八近一，0-7 ，以數(shù)值0開頭 ，%o ：補碼占位 十六進制：逢十六進一，0-F ，以0x開頭，如0x123 ，%n ：補碼占位 十進制轉(zhuǎn)二進制 十進制轉(zhuǎn)八進制 十進制轉(zhuǎn)十六進制 小數(shù)轉(zhuǎn)二進制
在有符號開頭中的第一個位經(jīng)常表示正負
1表示為負
0表示為正
反碼
源碼：正數(shù)的源碼 等于反碼等于補碼 在計算過程中正碼計算是有錯誤的 反碼：在正數(shù)的反碼是不變的，負數(shù)的反碼(符號位不變，其他位取反)，如果計算機用反碼進行存儲，負數(shù)運算結(jié)果是正確的，但是0的狀態(tài)還是有兩種 補碼：正數(shù)的補碼不變，負數(shù)的補碼等于反碼加1，如果計算機用補碼去存儲，負數(shù)運算結(jié)果是正確的，0的狀態(tài)只有一種
補碼求源碼
補碼求反碼：符號位不變，其他位取反 反碼求源碼：反碼加1
變量賦值時
在變量賦值時，賦值是十進制，給的是源碼，如果賦值時給的八進制或者十六進制給的就是補碼 在打印的時候，用十進制打印，就是用的源碼，如果是八進制和十六進制，用的就是補碼。
在無符號的情況下對其打印如果是%d的需要進行轉(zhuǎn)碼
因為打印%d的時候變成了有符號的數(shù)
進制轉(zhuǎn)換
char bin[128]={0}; ：char bin[128]申請指定空間內(nèi)存。={0}將128字節(jié)的全部清空
_ltoa(要轉(zhuǎn)換的變量，轉(zhuǎn)換地址，轉(zhuǎn)換幾進制) ：進制轉(zhuǎn)換
小數(shù)轉(zhuǎn)換成二進制
運算符
賦值運算
邏輯運算符
判斷語句
if后面不能加這個分號符號 ： （;）
if (變量名> 條件)
{
過了條件運行;
//嵌套if
if(變量名> 條件)
{
}
}
else if
{
過了條件運行;
}
else
{
過了條件運行;
}
三木運算符
C++中的三目運算符（也稱條件運算符）是一種簡單的條件語句，用于根據(jù)一個條件的真假值來選擇不同的計算方式。
它的語法為：
條件表達式 ? 表達式1 : 表達式2;
其中，條件表達式為一個返回布爾值的表達式，如果它的結(jié)果為true，則執(zhí)行表達式1，否則執(zhí)行表達式2。
示例代碼：
int x = 10, y = 20;
int max_num = (x > y) ? x : y; // 如果x>y，則max_num=x，否則max_num=y
在上面的例子中，如果x>y，則三目運算符返回x，否則返回y，最終將返回的值賦給max_num變量。
a > b ? a : b ; //如果a大于b則返回a，反之返回b a < b ? a : b ; //如果a小于b則返回a，反之返回b
switch語句，執(zhí)行多條件分支語句
判斷只能是整型或者字符型，不可以是一個區(qū)間
C++中的switch語句用于多分支判斷，語法如下：
switch(expression){
case constant1:
//代碼塊1
break;
case constant2:
//代碼塊2
break;
default:
//默認代碼塊
break;
}
其中，expression是一個可求值的表達式，case后面的常量可以是整型、字符型、枚舉型或者變量值，用于匹配expression的值，如果匹配成功，則執(zhí)行相應(yīng)的代碼塊，執(zhí)行完畢后用break終止switch語句。如果所有的case都不匹配，則執(zhí)行default代碼塊，如果沒有default代碼塊，則switch語句不會做任何操作。
需要注意的是，case后面的常量必須是編譯時常量，即不能使用變量或者函數(shù)調(diào)用的返回值。
switch(表達式)
{
case 結(jié)果1：執(zhí)行語句;break;
case 結(jié)果2：執(zhí)行語句;break;
.....
default:執(zhí)行語句;break;
}
循環(huán)語句：while()
while(循環(huán)條件)
{
執(zhí)行循環(huán)內(nèi)容;
}
do…while循環(huán)語句
do-while循環(huán)是一種后測試循環(huán)語句，它與while循環(huán)的區(qū)別在于它至少執(zhí)行一次循環(huán)體。語法如下： 不管條件是否滿足先執(zhí)行一次循環(huán)語句，在進行判斷看接下來的循環(huán)
do {
// 循環(huán)體
} while (條件表達式);
for循環(huán)
在 C++ 中，for 循環(huán)用于重復(fù)執(zhí)行一定次數(shù)的代碼。for 循環(huán)的語法如下:
for (initialization; condition; increment) {
// code to be executed
}
initialization - 在循環(huán)開始前執(zhí)行一次的代碼，通常用于初始化循環(huán)計數(shù)器。condition - 每次迭代前都會被檢查的條件。如果為 true，則執(zhí)行循環(huán)體中的代碼；否則跳出循環(huán)。increment - 在循環(huán)體執(zhí)行完之后執(zhí)行的代碼，通常用于遞增或遞減循環(huán)計數(shù)器的值。
下面是一個簡單的 for 循環(huán)示例：
for (int i = 0; i < 10; i++) {
cout << i << endl;
}
這個循環(huán)將執(zhí)行 10 次，每次輸出一個數(shù)字。
if判斷
||：這個符號為或
if(判斷條件 || 判斷條件2 || 判斷條件3)
{
}
跳出循環(huán)：break：break是一種控制語句，可用于中斷循環(huán)語句（如for循環(huán)或while循環(huán)）或switch語句中的執(zhí)行
#include
using namespace std;
int main() {
for (int i = 1; i <= 10; i++) {
if (i == 6) {
cout << "中斷循環(huán)" << endl;
break;
}
cout << i << endl;
}
return 0;
}
結(jié)束本次循環(huán)：continue
用于在循環(huán)結(jié)構(gòu)中跳過當前迭代并進行下一次迭代。當continue語句出現(xiàn)在循環(huán)結(jié)構(gòu)中的某個代碼塊內(nèi)，它會立即終。
無條件跳轉(zhuǎn)語句：goto
goto后面跟著一個標簽（label），該標簽必須定義在當前函數(shù)中的某個位置，并且標簽后面必須緊跟一個語句。當程序執(zhí)行到goto語句時，會立即跳轉(zhuǎn)到標簽所在的位置，并從該位置開始執(zhí)行下一條語句
隨機數(shù)
rand()
數(shù)組
int 數(shù)組名[數(shù)組的長度] = {10，20，30，40}；
統(tǒng)計數(shù)組占用的空間：sizeof
通過總體的數(shù)據(jù)空間除于單獨空間等于數(shù)組的個數(shù)
數(shù)組元素的個數(shù) = sizeof(數(shù)組)/sizeof(數(shù)組[0])
數(shù)組的逆置
可以通過循環(huán)交換數(shù)組元素的方法實現(xiàn)數(shù)組的逆置，具體步驟如下：
定義一個數(shù)組，例如 int arr[] = {1, 2, 3, 4, 5}; 計算數(shù)組的長度，例如 int len = sizeof(arr) / sizeof(arr[0]); 定義兩個指針，一個指向數(shù)組的開頭，一個指向數(shù)組的結(jié)尾，例如 int *start = arr; int *end = arr + len - 1; 循環(huán)交換數(shù)組元素，直到指針 start 大于等于指針 end。
while (start < end) {
int temp = *start;
*start = *end;
*end = temp;
start++;
end--;
}
最終數(shù)組 arr 的元素順序?qū)荒嬷谩?/p>
完整代碼：
#include
using namespace std;
int main() {
int arr[] = {1, 2, 3, 4, 5};
int len = sizeof(arr) / sizeof(arr[0]);
int *start = arr;
int *end = arr + len - 1;
while (start < end) {
int temp = *start;
*start = *end;
*end = temp;
start++;
end--;
}
for(int i = 0; i < len; i++) {
cout << arr[i] << " ";
}
cout << endl;
return 0;
}
數(shù)組的冒泡排序
#include
#include
#include "my_tools.h"
#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;
int main() {
int arr[9] = {8,2,6,4,3,1,5,7,9};
cout << "排序前" << endl;
for (int i = 0; i < 9; i++)
{
cout << arr[i] << " ";
}
cout << endl;
//開始冒泡程序
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9 - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
cout << "排序前" << endl;
for (int i = 0; i < 9; i++)
{
cout << arr[i] << " ";
}
cout << endl;
system("pause");
}
第2種
#include
using namespace std;
void bubbleSort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
swap(arr[j], arr[j + 1]);
}
}
}
}
int main() {
int arr[] = {5, 2, 9, 4, 7, 3};
int n = sizeof(arr) / sizeof(arr[0]);
cout << "Original array: ";
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
bubbleSort(arr, n);
cout << "\nSorted array: ";
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
return 0;
}
二維數(shù)組
C++中二維數(shù)組是由多個一維數(shù)組組成的數(shù)組。一般來說，使用二維數(shù)組可以方便地處理具有多個維度的數(shù)據(jù)，例如矩陣。
定義一個二維數(shù)組的語法如下：
數(shù)據(jù)類型 數(shù)組名[行數(shù)][列數(shù)];
例如，下面的代碼定義了一個名為matrix的二維數(shù)組，它有3行和4列：
int matrix[3][4];
我們可以通過指定行數(shù)和列數(shù)來初始化二維數(shù)組，例如：
int matrix[3][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
使用二維數(shù)組時，可以使用兩個循環(huán)來遍歷所有元素。例如，下面的代碼遍歷了一個3行4列的矩陣，并打印出每個元素的值：
for(int i=0; i<3; i++) {
for(int j=0; j<4; j++) {
std::cout << matrix[i][j] << " ";
}
std::cout << std::endl;
}
int arr[2][3]=
{
{1,2,3},
{4,5,6}
};
int arr[2][3] = {1,2,3,4,5,6,}
查看二維數(shù)組行數(shù)和列數(shù)多少
數(shù)組的行數(shù) : sizeof(數(shù)組)/sizeof(數(shù)組[0])
數(shù)組的列數(shù) : sizeof(數(shù)組[0])/sizeof(數(shù)組[0][0])
其中，sizeof(arr) 表示數(shù)組總共占用的字節(jié)數(shù)，sizeof(arr[0]) 表示數(shù)組中第一行占用的字節(jié)數(shù)。通過這兩個值的比較即可得到行數(shù)和列數(shù)。注意，此方法僅適用于靜態(tài)數(shù)組，對于動態(tài)分配的二維數(shù)組需要使用其他方式獲取行數(shù)和列數(shù)。
二維數(shù)組的案例，用于存儲學(xué)生的成績信息并打印輸出：
#include
using namespace std;
int main() {
//onst是一個關(guān)鍵字，用于限制變量、指針或者函數(shù)的值或參數(shù)在程序的執(zhí)行過程中不能被修改
const int NUM_STUDENTS = 3; // 學(xué)生數(shù)量
const int NUM_SUBJECTS = 2; // 科目數(shù)量
// 聲明二維數(shù)組用于存儲學(xué)生的成績信息
int grades[NUM_STUDENTS][NUM_SUBJECTS];
// 循環(huán)輸入每個學(xué)生的成績
for (int i = 0; i < NUM_STUDENTS; i++) {
cout << "請輸入第 " << i+1 << " 個學(xué)生的成績：" << endl;
for (int j = 0; j < NUM_SUBJECTS; j++) {
cout << "科目 " << j+1 << "：";
cin >> grades[i][j];
}
}
// 循環(huán)輸出每個學(xué)生的成績
for (int i = 0; i < NUM_STUDENTS; i++) {
cout << "第 " << i+1 << " 個學(xué)生的成績：" << endl;
for (int j = 0; j < NUM_SUBJECTS; j++) {
cout << "科目 " << j+1 << "：" << grades[i][j] << endl;
}
}
return 0;
}
頭文件定義: 文件.h
#include
using namespace std;
寫入創(chuàng)建的函數(shù),函數(shù)聲明
函數(shù)聲明.cpp中要調(diào)用頭 文件.h文件
#include 文件.h
主函數(shù)文件也要調(diào)用 頭 文件.h
#include 文件.h
寫一個加法的函數(shù)
int main() {
int a = 10, b = 20;
int sum = add(a, b); // 調(diào)用 add 函數(shù)計算 a 和 b 的和
cout << "The sum of " << a << " and " << b << " is " << sum << endl;
return 0;
}
寫一個函數(shù)的調(diào)用的示例代碼
#include
// 定義一個函數(shù)
int add(int a, int b) {
return a + b;
}
int main() {
// 調(diào)用函數(shù)
int result = add(2, 3);
// 打印函數(shù)的返回值
std::cout << "The result is: " << result << std::endl;
return 0;
}
指針
int * p = NULL; //空指針用于給指針變量進行初始化,這個為空指針
int * p = 0xxx; //野指針就是非法指針,對指定地址沒有權(quán)限
int a=10
int * p
p = &a //指針指向數(shù)據(jù)a的地址
c++中sizeof
c++中的野指針
C++ 中的野指針是指一個指針變量，它保存了一個無效或者未初始化的內(nèi)存地址，即一個不受控制的地址。這種指針可能指向一個沒有分配給你的內(nèi)存位置，或者指向一個已經(jīng)被釋放的內(nèi)存區(qū)域。野指針是一種常見的編程錯誤，可能會導(dǎo)致程序崩潰、未定義行為或者不可預(yù)測的結(jié)果。
以下是一個例子，展示了野指針的情況：
#include
int main() {
int *wildPtr; // 未初始化的指針，成為野指針
// 假設(shè)在這里發(fā)生了一些代碼，沒有為 wildPtr 分配內(nèi)存
// 嘗試解引用野指針會導(dǎo)致未定義行為
// int value = *wildPtr; // 這行代碼會導(dǎo)致問題
return 0;
}
在這個示例中，指針 wildPtr 被聲明為一個整數(shù)指針，但是沒有被初始化或者分配內(nèi)存。嘗試解引用這個指針將會導(dǎo)致未定義行為，因為它指向了一個未知的內(nèi)存地址。
為了避免野指針問題，你可以遵循以下幾點：
初始化指針：在聲明指針的同時，將其初始化為 nullptr，以確保它不包含任何無效地址。在 C++11 及之后的標準中，可以使用 nullptr 來初始化指針。 int *ptr = nullptr; // 初始化指針為 nullptr
指針使用前檢查：在使用指針之前，先檢查它是否為 nullptr，以避免解引用野指針。 if (ptr != nullptr) {
int value = *ptr; // 只有在指針不為 nullptr 時解引用
}
謹慎使用動態(tài)內(nèi)存分配：使用 new 關(guān)鍵字分配內(nèi)存時，要確保在不需要使用這塊內(nèi)存時使用 delete 釋放它。避免忘記釋放內(nèi)存，以防止出現(xiàn)野指針。 int *dynamicPtr = new int;
// 使用 dynamicPtr
delete dynamicPtr; // 釋放內(nèi)存，避免野指針
總之，野指針是一個需要注意的問題，為了避免未定義行為和程序崩潰，始終確保你的指針在使用前都是有效和正確初始化的。
const修飾指針
常量指針:指針指向可以改,指針指向的值不能修改
const int * p = &a;
指針常量:指針指向不能修改,指針指向的值可以修改
int * const p = &a;
指針指向和指針指向的值都不能修改
const int * const p = &a
指針指向數(shù)組
創(chuàng)建一個數(shù)組
int arr[4] = {1,2,3,4};
創(chuàng)建一個指針,指向arr數(shù)組
int * p = arr
第一個元素為*p
p++
第二個元素
指針和函數(shù)
三種值的傳遞方式：值傳遞、引用傳遞和指針傳遞。
C++中有三種值的傳遞方式：值傳遞、引用傳遞和指針傳遞。
值傳遞：
值傳遞是將函數(shù)參數(shù)的值復(fù)制一份給函數(shù)的形參，形參和實參之間沒有任何關(guān)系，函數(shù)運行結(jié)束后，形參的值也會被銷毀，不會對實參產(chǎn)生影響。
示例代碼：
#include
using namespace std;
//形參，形參進行改變也改變不了實參的值
void swap(int a, int b)
{
int temp = a;
a = b;
b = temp;
}
//實參
int main()
{
int x = 10, y = 20;
swap(x, y);
cout << "x = " << x << ", y = " << y << endl;
return 0;
}
輸出結(jié)果為：
x = 10, y = 20
可以看到，雖然在swap函數(shù)中交換了a和b的值，但是在main函數(shù)中x和y的值并沒有被改變，因為是值傳遞，函數(shù)中的a和b只是x和y的拷貝。
引用傳遞：
引用傳遞是將函數(shù)參數(shù)的引用傳遞給函數(shù)的形參，形參和實參之間共用同一個內(nèi)存地址，函數(shù)運行結(jié)束后，形參和實參都指向同一個內(nèi)存地址，實際上是對實參進行的修改。
示例代碼：
#include
using namespace std;
void swap(int &a, int &b)
{
int temp = a;
a = b;
b = temp;
}
int main()
{
int x = 10, y = 20;
swap(x, y);
cout << "x = " << x << ", y = " << y << endl;
return 0;
}
輸出結(jié)果為：
x = 20, y = 10
可以看到，使用引用傳遞的方式，函數(shù)中的a和b是x和y的引用，實際上是對x和y進行的操作，所以在交換之后，x和y的值得到了真正的修改。
指針傳遞：
指針傳遞是將函數(shù)參數(shù)的指針作為實參傳遞給形參，形參是指針類型，可以通過指針來操作實參的值，實際上和引用傳遞的方式十分相似。
示例代碼：
#include
using namespace std;
void swap(int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
int main()
{
int x = 10, y = 20;
swap(&x, &y);
cout << "x = " << x << ", y = " << y << endl;
return 0;
}
輸出結(jié)果和引用傳遞的方式相同：
x = 20, y = 10
總的來說，值傳遞只是傳遞了實參的一個副本，使用時要注意，如果需要在函數(shù)中修改實參的值，應(yīng)該使用引用傳遞或指針傳遞的方式。
函數(shù)的聲明
返回類型 函數(shù)名稱(參數(shù)列表);
int add(int a, int b);
以下是關(guān)于函數(shù)聲明的一些注釋：
函數(shù)聲明只需要描述函數(shù)的接口，不需要具體實現(xiàn)。
函數(shù)聲明通常放在頭文件中，以供其他文件使用。
如果函數(shù)在引用前沒有聲明，則編譯器會報錯。
函數(shù)可以在一個文件中聲明，而在另一個文件中實現(xiàn)。
同一個文件中的函數(shù)可以在 main 函數(shù)之后定義，但是它們需要在 main 函數(shù)之前被聲明。
函數(shù)的分文件編寫
**作用：**讓代碼結(jié)構(gòu)更加清晰
函數(shù)分文件編寫一般有4個步驟
創(chuàng)建后綴名為.h的頭文件創(chuàng)建后綴名為.cpp的源文件在頭文件中寫函數(shù)的聲明在源文件中寫函數(shù)的定義
示例：
1：swap.h文件
//
#include
using namespace std;
//實現(xiàn)兩個數(shù)字交換的函數(shù)聲明
void swap(int a, int b);
2：swap.cpp文件
//swap.cpp文件
#include "swap.h"
void swap(int a, int b)
{
int temp = a;
a = b;
b = temp;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
}
3：main函數(shù)文件
//main函數(shù)文件
#include "swap.h"
int main() {
int a = 100;
int b = 200;
swap(a, b);
system("pause");
return 0;
}
結(jié)構(gòu)體:自定義數(shù)據(jù)類型
創(chuàng)建自定義數(shù)據(jù)類型
struct Struct{
string name;
int age;
int score;
};
通過main函數(shù)調(diào)用自定義數(shù)據(jù)類型
int main(){
//方法1賦值
struct Struct s1;
s1.name = "張三"; //調(diào)用自定義的數(shù)據(jù)name
s1.age = 18; //調(diào)用自定義的數(shù)據(jù)age
s1.score = 100; //調(diào)用自定義的數(shù)據(jù)score
//方法2賦值
struct Struct s2 = {"張三",18,100};
}
//方法3:直接在定義函數(shù)后寫上s3,對s3進行調(diào)用
struct Struct{
string name;
int age;
int score;
}s3;
s3.name = "張三"; //調(diào)用自定義的數(shù)據(jù)name
s3.age = 18; //調(diào)用自定義的數(shù)據(jù)age
s3.score = 100; //調(diào)用自定義的數(shù)據(jù)score
結(jié)構(gòu)體數(shù)組
struct 結(jié)構(gòu)體名 數(shù)組名[元素個數(shù)] = {{},{},{},{}}
創(chuàng)建自定義數(shù)據(jù)類型
struct Struct{
string name;
int age;
int score;
};
使用main()函數(shù)進行數(shù)組的添加
main(){
struct Struc stuarray[3] =
{
{"張三",18,100}
{"李四",19,82}
........
};
}
通過遍歷結(jié)構(gòu)體數(shù)組
for(int i =0 ;i<3,i++)
{
cout<<"姓名"< <<"姓名"< <<"姓名"< } 使用結(jié)構(gòu)體指針 struct Struct{ string name; int age; int score; }; int main（）{ Struct s = {"張三",18,100}; Struct * p = &s cout>> p->name>>endl; system("pause") return 0 ; } 結(jié)構(gòu)體嵌套結(jié)構(gòu)體 struct student { string name; int age; int score; }; struct teacher { string name; int age; int score; struct student stu; //嵌套上面結(jié)構(gòu)體 } main(){ teacher t; t.name = "老師" .... t.stu.name = "學(xué)生" ..... } 結(jié)構(gòu)體做參數(shù) 注意如果要修改主函數(shù)中的數(shù)據(jù)，用值傳遞，反之用地址傳遞， struct student { string name; int age; int score; }; //值傳遞 void printStudent1(struct student s) { cout< } //地址傳遞 void printStudent2(struct student * p) { p->age = 150; //這里的修改也可以對主函數(shù)上進行修改，如果是值函數(shù)傳遞，主函數(shù)不會修改而且還要進行備份，占用空間大 cout< name <<....< } main(){ struct student s; s.name = "老師" printStudent1(s); printStudent2(&s); } 結(jié)構(gòu)體中的const使用場景 作用：用const來防止誤操作 struct student { string name; int age; int score; }; //將函數(shù)中的形參改為指針，可以減少內(nèi)存空間，而且不會復(fù)制新的副本出來 void printStudent1(const student *s) //為了防止誤操作在形參中加入const的 { //s->age = 150; //這里的修改也可以對主函數(shù)上進行修改，如果是值函數(shù)傳遞，主函數(shù)不會修改而且還要進行備份，占用空間大 ，加入const之后就不能在這上面進行修改 cout< } main(){ struct student s; s.name = "老師" printStudent1(&s); } 利用new關(guān)鍵字，可以將數(shù)據(jù)開辟到堆區(qū) int * func() { //利用nue關(guān)鍵字，開辟到堆區(qū) //指針本質(zhì)也是局部變量，放在棧上，指針保存的數(shù)據(jù)存放在堆區(qū) int * p = new int(10) // return p; } int main() { //在堆區(qū)開辟數(shù)據(jù) int * p = func(); system("pause") } 利用delete來手動釋放 delete p; 靜態(tài)變量 static int 變量名 = 10; //靜態(tài)變量 柚子快報邀請碼778899分享：c++基礎(chǔ) 好文鏈接
本文內(nèi)容根據(jù)網(wǎng)絡(luò)資料整理，出于傳遞更多信息之目的，不代表金鑰匙跨境贊同其觀點和立場。
轉(zhuǎn)載請注明，如有侵權(quán)，聯(lián)系刪除。
Takelot淘樂優(yōu)選
