#include <iostream>

#include <string>? //string 類

#include <string.h> //也是字符串

#include <stdlib.h>

#include <vector>

#include <array>

using namespace std;

inline double sq(double x )

{

? ? return x*x;

}

int main ()

{

? ? double x;

? ? std::cout << "輸入一個數(shù)：" << std::endl;

? ? cin>>x;

? ? std::cout << "這個數(shù)字的平方是" << sq(x)<< std::endl;

? ? return 0;

}

/* C++ 允許程序在任何地方聲明新的變量? 還允許在創(chuàng)建變量時對他進行賦值（這就是初始化）

coutfill('%')和setfill('%')在從設(shè)置行向后，才能填充設(shè)置的字符

long是代表長雙精度型 long long?

類是用戶定義的一種數(shù)據(jù)類型，描述其能夠表達(dá)什么數(shù)據(jù)信息（也就是屬性）；還有一個就是可對數(shù)據(jù)執(zhí)行那些操作（方法）定義類：數(shù)據(jù)格式+使用方法? 對象是根據(jù)數(shù)據(jù)格式規(guī)范創(chuàng)建的實體

C++ 提供兩種發(fā)送消息的方式，一種是使用類方法，本質(zhì)上就是使用函數(shù)調(diào)用；另一種就是重新定義運算符。

C++ 的函數(shù)分為兩種，有返回值的和沒有返回值的。

有返回值的函數(shù)? ?調(diào)用函數(shù) 被調(diào)用函數(shù)? 返回函數(shù)?

C++程序應(yīng)當(dāng)為程序中使用的每個函數(shù)提供原型? ?就是函數(shù)的整個調(diào)用使用的整套格式（這就是原型）? 不是函數(shù)

C++庫函數(shù)存儲在庫文件中，編譯器編譯程序時，必須在庫文件中搜索您使用的函數(shù)。

在設(shè)計類的時候，需要自己編寫函數(shù)。

在進行子函數(shù)的調(diào)用時，要將寫好的子函數(shù)在頭文件或者主函數(shù)內(nèi)部進行一個聲明（也就是函數(shù)頭），不然函數(shù)會報錯? ?void 說明函數(shù)不會有返回值? 如果這么聲明說明不需要return.

main 函數(shù)的 return 0;? 返回語句只適用于main函數(shù)，不適用與其他函數(shù)? 可以看成是操作系統(tǒng)調(diào)用main函數(shù)，所以main函數(shù)的返回值是返回給操作系統(tǒng)

關(guān)鍵字： int? void? return? double? ?main不是關(guān)鍵字 他不是語言組成的一部分 是一個必不可少的函數(shù)名稱??

用戶定義的有返回值的函數(shù)? 就是將前面和的 void換成其他就可以了。

從main執(zhí)行 函數(shù)頭 函數(shù)體?

可以使用#define 和const 指定常量? ?#define N 100（這個在頭文件下面）? ? ?const int N=100;(任意位置)

auto 自動類型推斷

判斷語句? if? 和 else 后面應(yīng)該格子分開包裹大括號? ?switch 就是多選擇??

函數(shù)? 形參不聲明 子函數(shù)可以寫在主函數(shù)上下都行? 其余沒啥變化

匿名函數(shù)? lambda函數(shù)/表達(dá)式? ?只是用一次的函數(shù)對象類 直接在其使用的地方定義? 還沒學(xué)會

=是不允許 & 允許? 表示{}中用到的，定義在大括號外面的變量在{}中是否被允許改變? 這個表示定義在{}外面的變量在大括號中不允許被改變

布爾型就是邏輯型

遞歸? 就是調(diào)用自身? 去實現(xiàn)某些功能? ?寫一個子函數(shù)? 這個子函數(shù)里面有調(diào)用其本身的字眼就行? 然后再在主函數(shù) 進行調(diào)用。

內(nèi)聯(lián)函數(shù) 通常與類一起使用? 在編譯時 編譯器會把該函數(shù)的代碼副本放在每個調(diào)用該函數(shù)的地方。對內(nèi)聯(lián)函數(shù)的任何修改，都需要重新編譯函數(shù)所有的客戶端，因為編譯器需要重新更換所有的代碼，否則將會繼續(xù)使用舊的函數(shù)? 形式：? 子函數(shù)函數(shù)名前面加上 inline? ?//前面加個inline? 相當(dāng)于將整個子函數(shù)在調(diào)用的位置上重新寫了一遍

傳值和傳址的理解? 傳值? 就是穿進去的參數(shù)跑進去跑出來不會變? 但是傳值跑進去的跑出來就變了

函數(shù)重載? 函數(shù)名相同 但是形參的格式不同 同一個函數(shù)名還是要在主函數(shù)前面聲明一下，使用的時候還是根據(jù)其功能使用? ?目的是為了方便使用函數(shù)名

靜態(tài)局部變量 靜態(tài)全局變量? ? 拒不存儲位置不變 編譯時才會賦值? ? 都是 static? 還有靜態(tài)函數(shù)也是這種表述 這樣表述的函數(shù)只能被本文所使用?

全局變量? 可被其他文件調(diào)用的函數(shù) 都使用 extern? ?一般省略 extern 直接看成可以被其他文件進行調(diào)用? 調(diào)用是時使用 還是extern 或者 #include

數(shù)組? 這個都能明白? 字符串?dāng)?shù)組? 一個char 寬度為一個字節(jié)? ?字符串后面還跟著一個 \0? 是為了截斷 換行? 數(shù)組之間不能直接賦值 要挨個賦值? 也就是要寫個循環(huán)賦值 */

//結(jié)構(gòu)體? 結(jié)構(gòu)體數(shù)組?

/* struct student? ?//結(jié)構(gòu)的使用? 這是全局結(jié)構(gòu)聲明? 也可以局部聲明

{

? ? char name[20];? //類型1 字符串?

? ? float shengao; //類型2 浮點數(shù)

? ? double tizhong; //類型3 雙精度浮點數(shù)

};

// 程序的主函數(shù)

int main(int argc, char const *argv[])

{

? ? struct student first1 =? ? ? ? ? ? ? //struct 可要可不要? ?等號 = 可要可不要? 可函數(shù)內(nèi)部可函數(shù)外部? 但是盡量變量放在內(nèi)部聲明不出去

? ? {

? ? ? ? "wangjie", 1.87,93.5

? ? };

? ? struct student first2 =

? ? {

? ? ? ? "lihui", 1.87,93.5

? ? };

? ? cout << "第一個學(xué)生的屬性：" << "\n"<< " 姓名："? << first1.name << " 身高：" << first1.shengao << " 體重： " << first1.tizhong <<endl;?

? ? return 0;

} */

/* 結(jié)構(gòu)體? 數(shù)組之間的賦值

struct student

{

? ? char name[20];

? ? float zhongliang;

? ? double shengao;

}stu1;

int main(int argc, char const *argv[])

{

? ? struct student stu[2] =?

? ? {

? ? ? ? {"wangjie",92.5,1.87},

? ? ? ? {"lihui",92.5,1.87}

? ? };

? ? int i;

? ? std::cout << "學(xué)生1的名字：" << stu[0].name << "? 學(xué)生1的重量：" << stu[0].zhongliang << "? 學(xué)生1的身高： " << stu[0].shengao << std::endl;

? ??

? ? struct student choice[2];

? ? for ( i = 0; i < 2; i++)

? ? {

? ? ? ? choice[i] = stu[i];

? ? ? ? std::cout << i << "? "<< "choice：" << choice[i].name << choice[i].zhongliang << choice[i].shengao << std::endl;

? ? }

? ? return 0;

} */

// 指針與C++基本原理：面向?qū)ο缶幊膛c傳統(tǒng)面向過程編程的區(qū)別在于：OOP強調(diào)的是在運行階段（而不是編譯階段）進行決策，運行階段指的是程序在運行時，編譯階段指的是編譯器將程序組合起來時。? ?運行階段決策提供了靈活性，可以根據(jù)當(dāng)時的情況進行調(diào)整。OOP通過將程序需要的內(nèi)存在運行時再去告訴計算機，這樣就不會浪費內(nèi)存。 OOP在運行階段確定數(shù)組長度，C++允許在程序運行時創(chuàng)建數(shù)組（使用關(guān)鍵字new請求正確數(shù)量的內(nèi)存以及使用指針來跟組新分配的內(nèi)存的位置）

// 處理存儲數(shù)據(jù)時恰好相反 將變量的物理地址（這就是指針）視為指定的量，而將其值視為派生量，指針可以看做是存儲變量值的地址，所以指針名表示的是地址。 *運算符被成為間接值或者叫作解除引用運算符? 使用這個就會表達(dá)出來這個地址位置存儲的變量的值? ?& 叫取址符 使用這個符號表達(dá)的意思就是取出這個物理量的存儲位置（物理地址）

// int main(int argc, char const *argv[])

// {

//? ? ?int wanshang = 1001;? //整型

//? ? ?int *pt =new int; //將整型的地址賦給一個指針，只能通過指針進行訪問? 為這種類型的數(shù)據(jù)對象獲取指定分配內(nèi)存

//? ? ?*pt = 1001;? ? ?

//? ? ?std::cout << "（這是個整型）wanshang的物理值? " << wanshang <<std::endl;

//? ? ?std::cout << "wanshang的內(nèi)存地址? ?" << &wanshang<< std::endl;

//? ? ?std::cout << "int 的值 " << *pt << "；int的位置 "<<pt<< std::endl;

//? ? ?return 0;

// }

// 要創(chuàng)建指針變量 每一個前面都需要加*?

// 指針：用來分配存儲地址的內(nèi)存，而不是分配存儲指針?biāo)赶驍?shù)據(jù)的內(nèi)存

// 一定要在對指針應(yīng)用解除引用運算符*之前，將指針初始化為一個確定的、適當(dāng)?shù)牡刂贰＃ń鹂朴衤桑?/p>

// 指針管理運行階段的內(nèi)存空間分配

/* int main(int argc, char const *argv[])

{

? ? int a = 10,c=30;

? ? const int b =20;? ??

? ? const int i = 20;

? ? int k = 40;

? ? const int * p ;??

? ? p = &i;? //只可指向i? 不可修改i

? ? cout <<*p <<"? ?"<< i<< endl;

? ? p= &k;

? ? cout << *p << k;

? ? int p;

? ? p=*p1;

? ? *p1=*p2;

? ? *p2=p;? ?//指針變量之間的物理數(shù)值的調(diào)換

? ? double wa[3] = {10000.0,20000.0,30000.0};

? ? short st[3] = {3,2,1};

? ? // 使用指針

? ? double * pw = wa;??

? ? short *ps= &st[0];? // 取的是數(shù)組第一個下標(biāo)的物理地址? 所以是一個指針常量

? ? cout <<" pw " << pw <<"? * pw = "<<*pw <<endl;//取值 wa是一個數(shù)組? 取的是第幾個數(shù)值? 指向的是wa這個數(shù)組的地址

? ? pw+=1;

? ? std::cout << "給指針變量加1 \n"? << std::endl;? //相當(dāng)于給數(shù)組的下標(biāo)往后走了一位 所以是20000

? ? cout <<" pw " << pw <<"? * pw = "<<*pw <<endl;

? ? cout <<" ps " << ps <<"? * ps = "<<*ps <<endl;? //取的是數(shù)組第一個? 3? 的物理地址

? ? ps+=1;

? ? std::cout << "給ps的指針變量加1" <<" ps " << ps <<"? * ps = "<<*ps<< std::endl;

? ? std::cout << "st[0]" <<st[0]<<"\n"<< "st[1]" <<st[1]<< std::endl;

? ? std::cout << "*st ="<< *st <<"\n"<<"*(st+1) = " <<*(st+1)? << std::endl;? ?//指針數(shù)組的指向作用

? ? return 0;

} */

//指向常量的指針變量? const int i =20? 只可讀取 不可修改

// 整型的常量和指針常量? 都是不可修改的? 字符型的指針常量? 指針指向的地方不能修改 但是代表的字符常量可以修改? 指針指向的變量是可以修改的

//指針在參數(shù)傳遞中有三個作用（也就是指針作為函數(shù)進行參數(shù)傳遞的三個作用）：

// 1 形參實參指向共同的內(nèi)存空間，達(dá)到參數(shù)雙向傳遞的目的

// 2 減少函數(shù)調(diào)用時數(shù)據(jù)傳遞的開銷

// 3 傳遞實際參數(shù)的首個地址 （弄了半天是作用最小的那個）

//數(shù)組名就代表這數(shù)組的首地址? 也就是數(shù)組中下標(biāo)序號為0 的元素的地址

/* int main(int argc, char const *argv[])

{

? ?double a1[4] {1.2,2.4,3.6,4.8};

? ?vector<double> a2(4);

? ?a2[0]=1.0/3.0;

? ?a2[1]=1.0/5.0;

? ?a2[2]=1.0/7.0;

? ?a2[3]=1.0/9.0;

? ?array<double,4>? ?a3 {3.14,2.72,1.62,1.41};

? ?array<double,4>? ?a4;

? ?a4 =a3;

? ?std::cout << "a1[2] " <<a1[2]<< std::endl;

? ?std::cout << "a2[2] " <<a2[2]<< std::endl;

? ?std::cout << "a3[2] " <<a3[2]<< std::endl;

? ?std::cout << "a3[2] " <<a4[2]<< std::endl;?

}*/

/*? C++ 分配內(nèi)存的方法： 自動存儲、靜態(tài)存儲、動態(tài)存儲、自由存儲空間或堆

模板類 vector 是一種動態(tài)數(shù)組，是使用new創(chuàng)建動態(tài)數(shù)組的替代品

1 必須包含頭文件 vector ；2 必須包含在std 名空間中? 就是直接聲明使用名空間就好了；3 模板使用不同的語法來指出他的數(shù)據(jù)類型 4 vector 類使用不同的語法來指定元素數(shù)? ?

模板類:

vector<typeName> vt(n_elem);

array<typeName,n_elem> arr;? 這個n_elem? 不能是變量? ? ? ? ?

引用 不論是引用變量、指針變量、函數(shù)? 都是在前面加 &? 符號，函數(shù)傳址是在前面加上 * 符號? 引用變量在內(nèi)存中沒有地址，和被引用的使用同一個內(nèi)存地址??

作為函數(shù)引用效果和傳遞指針的效果一樣

常引用的作用有兩個，一是讓變量所指向的內(nèi)存空間只讀，二是能夠指向常量? ? void getTeacher(const teacher &t)? 也就是在子函數(shù)的形參中? 不僅寫出const 再在需要引用的變量前面加上引用地址符 &

常引用 const int &a=b 相當(dāng)于 const int * const a=b 不僅僅是a這個地址不可修改，而且其指向的內(nèi)存空間也不可修改

?*/

/*? 類 還是 結(jié)構(gòu)的變化體 聲明的時候注意聲明的對象首字母要大寫 大括號中包含 private? protected? public? 這三種不同權(quán)限的數(shù)據(jù)成員或者叫作成員函數(shù)? ?這只是三種不同的權(quán)限? 在定義成員函數(shù)的時候 需要加上? ::? 這個符號用以特指? 返回值類型 類的名稱::成員函數(shù)名（引入的參數(shù)）。

一般做法：將類的定義卸載一個頭文件中（.h文件），將成員函數(shù)的定義寫在一個程序文件中（.cpp）。這樣子相當(dāng)于把類的定義看成了類的外部接口，而把成員函數(shù)看成是類的內(nèi)部實現(xiàn)。

.cpp 文件先要包含其他頭文件? 還要包含你定義的這個頭文件，這個頭文件才能發(fā)揮作用。

對象：類的實例? 類是一種抽象的數(shù)據(jù)類型，對象是實際的概念 對象是屬于該類的一個變量? 每個對象都具有該類的一套數(shù)據(jù)成員，所有成員函數(shù)的所有對象共有的。

類中的私有成員只能通過其成員函數(shù)進行訪問 ，也就是說 private里面和public里面 有一個交界? 這個交界就是成員函數(shù)? 私有其實就是為了限制權(quán)限? 訪問私有必須通過向?qū)ο蟀l(fā)送同類型的消息? ?注意同類型

純虛函數(shù)：就是直接定義虛函數(shù)為0? ?virtual 函數(shù)原型 =o;

抽象類：就是包含純虛函數(shù)的類，不能有對象，因為它的數(shù)據(jù)類型直接為0，就沒有對象，可以聲明其指針變量和引用變量? 可以有多個純虛函數(shù)、非純虛函數(shù)? ?類繼承越復(fù)雜 上層的類抽象程度越高，所以抽象類一般居于類繼承結(jié)構(gòu)的較上層。

友元函數(shù)? 就是在定義類的成員函數(shù)時? 在這個成員函數(shù)前面加個? friend? ? 這樣子? 這個

?*/

/* #include <iostream>

#include <string>? //string 類

#include <string.h> //也是字符串

#include <stdlib.h>

#include <vector>

#include <array>

using namespace std;

class Complex? ?

{

? ? private:

? ? ? ? double r;

? ? ? ? double i;

? ? public:

? ? ? ? Complex(double x=0.0, double y=0.0)

? ? ? ? {

? ? ? ? ? ? r=x;

? ? ? ? ? ? i=y;

? ? ? ? }

? ? ? ? Complex operator +(const Complex &c);

? ? ? ? void print();? ?

? ??

};

? ? Complex Complex::operator+(const Complex &c)? ??

? ? ? ? {

? ? ? ? Complex t;

? ? ? ? t.r=r+c.r;

? ? ? ? t.i=i+c.i;

? ? ? ? return t;

? ? ? ? }

void Complex::print()

{

? ? std::cout <<'('<< r <<','<< i <<')'<< std::endl;? ?

? ??

}

int main()

{

? ? Complex a(3.0,4.0),b(10.5,20.5),c;

? ? c=a+b;

? ? c.print();

? ??

? ? return 0;

} */

/*? // 類模板 這是將函數(shù)成員定義體 放在 類模板 成員函數(shù)定義體 外部 定義的實例。

template <class T, int N > class ABC? //定義模板類

{

? ? private:

? ? T array[N];

? ? public:

? ? void set(int x)

? ? {

? ? ? ? int i;

? ? ? ? for ( i = 0; i < N; i++)

? ? ? ? {

? ? ? ? ? ? array[i]=x+i;

? ? ? ? ? ? // std::cout << i << std::endl;

? ? ? ? ? ? std::cout << "array["<< i<<"]="<< array[i] << std::endl;

? ? ? ? }

? ? ? ??

? ? }

? ? void get()

? ? {

? ? ? ? std::cout << "數(shù)組元素為"<<N << std::endl;

? ? ? ? std::cout << "array["<< N-1<<"]="<< array[N-1] << std::endl;

? ? }

};

int main(int argc, char const *argv[])

{

? ? ABC<int,50>abc1;

? ? abc1.set(0);

? ? abc1.get();

? ? ABC<int,100>abc2;

? ? abc2.set(10);

? ? abc2.get();

? ? return 0;

}? */

/*? ?//? 類模板? 這是將函數(shù)成員定義體 放在 類模板 成員函數(shù)定義體 內(nèi)部 定義的實例。

template <class T, int N > class ABC? //定義模板類

{

? ? private:

? ? T array[N];

? ? public:

? ? void set(int x);

? ? void get();

};

//將成員函數(shù)寫在外面

template <class T, int N >?

void ABC<T,N>::set(int x)

{

? ? int i;

? ? for ( i = 0; i < N; i++)

? ? {

? ? ? ? array[i]=x+i;

? ? ? ? // std::cout << i << std::endl;

? ? ? ? std::cout << "array["<< i<<"]="<< array[i] << std::endl;

? ? }

}

template <class T, int N >?

void ABC<T,N>::get()

{

? ? std::cout << "數(shù)組元素為"<<N << std::endl;

? ? std::cout << "array["<< N-1<<"]="<< array[N-1] << std::endl;

}

int main(int argc, char const *argv[])

{

? ? ABC<int,50>abc1;

? ? abc1.set(0);

? ? abc1.get();

? ? ABC<int,100>abc2;

? ? abc2.set(10);

? ? abc2.get();

? ? return 0;

}? */

/*? template <class T>

T maxx(T a, T b)

{

? ? a>b?a:b;

/*? ? ?if (a>b)

? ? {

? ? ? ? return a;

? ? }?

? ? else

? ? {

? ? ? ? return b;

? ? } */

? ? ? ??

? ? ??

/* }

int main()

{

? ? int i1=20,i2=10;

? ? double d1=-5.43,d2=50.23;

? ? char c1='A',c2='a';

? ? std::cout << "相比之下較大的為：" << maxx(i1,i2)<<std::endl;

? ? std::cout << "相比之下較大的為：" << maxx(d1,d2)<< std::endl;

? ? std::cout << "相比之下較大的為：" << maxx(c1,c2)<< std::endl;

? ? ?return 0;

} */?