//單行注釋
/*
多行注釋
多行注釋
*/

//x64處理器 64位window10 vs2015 
#include <iostream>
using namespace std;
int main()
{
	bool b;
	char c;short s; int i; long l; long long ll; float f; double d; long double ld;long float lf;
	unsigned char uc; unsigned short us; unsigned int ui; unsigned long ul; unsigned long long ull;
	cout << sizeof(bool) <<  endl;
	cout << sizeof(char)<<" " << sizeof(short)<<" "<< sizeof(signed int) << " " << sizeof(long) << " " << sizeof(signed long long) << " " << sizeof(float) << " " << sizeof(double) << " " << sizeof(long float) << " " << sizeof(long double) << endl;
	cout <<sizeof(unsigned char)<<" "<< sizeof(unsigned short) << " " << sizeof(unsigned int) << " " << sizeof(unsigned long) << " " << sizeof(unsigned long long) << endl;
	cout << sizeof(unsigned) << endl;
	cout << "hello World!!!" <<endl;
	system("pause");
	return 0;
}

//使用typedef為一個已有的類型取一個新的名字,語法如下：
typedef type newname
//eg：
typedef int feet
feet distance

//枚舉類型的語法:
enum 枚舉名{
	標(biāo)識符[=整型常數(shù)], 
     標(biāo)識符[=整型常數(shù)], 
... 
    標(biāo)識符[=整型常數(shù)]
}枚舉變量;

enum course {math,chinese,english,physics,chemistry}c;
c = english;
cout<<c<<endl;  //2
//english為1 physics為2 chemistry為3，chinese仍為1，math仍為0
enum course {math,chinese,english=1,physics,chemistry};

int x = y = z = 66;//錯誤
int x = 3,y = 3,z = 3;
int x, y ,z = 3;
x = y = z;

// 變量聲明
extern int a, b;
int main ()
{
  // 變量定義
  int a, b;
  // 初始化
  a = 23;
  b = 25;
  return 0;
}

int i = 66;
int main ()
{
  int i = 88;
  cout << i<<endl;//8
  return 0;
}
float f;
double d;
char c;
int *p;
int main()
{
	cout << i << f << d << c << p << endl;//000 00000000
	return 0
}

sizeof            //返回變量的大小，eg:sizeof(a)返回4 a是整型  sizeof(int)
Condition?X:Y     //三元運(yùn)算符 Condition為true，值為X，否則值為Y
,                //逗號表達(dá)式，值為最后一個表達(dá)式的值
.和->            //用于引用類、結(jié)構(gòu)和公用體的成員
Cast            //強(qiáng)制類型轉(zhuǎn)換符  eg:int(2.202)返回2
&              //指針運(yùn)算符 返回變量的地址
*             //指針運(yùn)算符  指向一個變量

while(conditon)//0為false,非0為true
{
	statement(s);
}

for(init;conditon;increment)//0為false,非0或什么也不寫為true
{
	statement(s);
}

int array[5] = { 11, 22, 33, 44, 55 };
for (int x : array)
{
	cout << x << " ";
}
cout << endl;
// auto 類型也是 C++11 新標(biāo)準(zhǔn)中的，用來自動獲取變量的類型
for (auto x : array)
{
	cout << x << " ";
}

int a[4] = { 4,3,2,1 };
for each (int var in a)
{
	cout << var << " ";
}

if(expr)
{
	statement;//如果expr為true將執(zhí)行的語句塊 
}
if(expr)
{
   statement1;// 如果expr為true將執(zhí)行的語句塊
}
else
{
   statement2;// 如果expr為false將執(zhí)行的語句
}
if(expr1)
{
   statement1;// 如果expr1為true將執(zhí)行的語句塊
}
elseif(expr2)
{
   statement2;// 如果expr2為true將執(zhí)行的語句塊
}
...
else
{
	statementElse;// 當(dāng)上面的表達(dá)式都為false執(zhí)行的語句塊
}

switch(expression){
    case constant-expression  :
       statement(s);
       break; 
    case constant-expression  :
       statement(s);
       break; 
    // 您可以有任意數(shù)量的 case 語句
    default : // 可選的
       statement(s);
}

char c = 'A';
	switch (c)
	{
	case 'A':
	case 'B':
	case 'C':
		cout << "及格了" << endl;
		break;
	default:
		cout << "不及格" << endl;
	}

//如果 Exp1 為真，則計(jì)算 Exp2 的值，結(jié)果即為整個 ? 表達(dá)式的值。如果 Exp1 為假，則計(jì)算 Exp3 的值，結(jié)果即為整個 ? 表達(dá)式的值
Exp1 ? Exp2 : Exp3;

//如果標(biāo)識符被#define定義過，執(zhí)行程序段1，否則執(zhí)行程序段2
#ifdef 標(biāo)識符
	程序段1
#else
	程序段2
#endif
//如果標(biāo)識符沒有被#define定義過，執(zhí)行程序段1，否則執(zhí)行程序段2
#ifndef 標(biāo)識符
	程序段1
#else
	程序段2
#endif
//如果表達(dá)式為true，執(zhí)行程序段1，否則執(zhí)行程序段2
#if 表達(dá)式
	程序段1
#else
	程序段2
#endif

int arr1[4] = {1,2,3,4};
int arr2[4] = { 1,2 };
int arr[4] = {0];//所有元素為0
static int arr3[3];
int arr4[4];
cout << "arr1:"<<arr1[0] << arr1[1] << arr1[2] << arr1[3] << endl;
cout << "arr2:" << arr2[0] << arr2[1] << arr2[2] << arr2[3] << endl;
cout << "arr3:" << arr3[0] << arr3[1] << arr3[2] << arr3[3] << endl;
cout << "arr4:" << arr4[0] << arr4[1] << arr4[2] << arr4[3] << endl;

int arr1[2][3];
int arr[2][3] = {0];//所有元素為0
int arr2[2][3] = { {1,2,3},{4,5,6} };
int arr3[2][3] = { 1,2,3 ,4,5,6 };
int arr4[2][3] = { {1},{4,6} };
int arr5[][3] = { 1,2,3 ,4,5,6 };

//字符串長度為8個字節(jié),最后一位是'\0'。
char array[10] = "yuanrui";//yuanrui\0\0\0
//也可以不用定義字符串長度，如：
char arr[] = "yuanrui";//yuanrui\0

double *p;
double arr[10];
p = arr;//p = &arr[0];
*(p+3);//arr[3]

int* arr1 = new int[2];//delete []arr1;
int* arr2 = new int[3]{ 1,2 };//delete []arr2

int m=2, n=3;
int** arr3 = new int*[2];//delete []arr3
for (int i = 0; i < 10; ++i)
{ 
	arr3[i] = new int[3]; // delete []arr3[i]
}
int* arr4 = new int[m*n];//數(shù)據(jù)按行存儲 delete []arr3

int * function();
int** function();

int a[3];
//第一種方法
cout<<sizeof(a)/sizeof(a[0])<<endl;
//第二種方法
cout << end(a) - begin(a) << endl;
//二維數(shù)組
int arr[5][3];
int lines = sizeof(arr) / sizeof(arr[0][0]);
int row = sizeof(arr) / sizeof(arr[0]);//行
int col = lines / row;//列
cout << row << "::"<<col << endl;
cout << end(arr) - begin(arr) << endl;//5行

函數(shù)類型 函數(shù)名(參數(shù)列表);
eg:
int max(int a,int b);//聲明函數(shù)時，a,b可以省略
int max(int,int);
void show();

函數(shù)類型 函數(shù)名(參數(shù)列表)
{
	函數(shù)體;
}
eg:
int max(int a,int b)
{
	int z;
	z = a>b?a:b;
	return z;
}

//傳值-修改函數(shù)內(nèi)的形式參數(shù)對實(shí)際參數(shù)沒有影響
int add(int value)
{
	value++;
	return value;
}
int main()
{
	int v = 10;
	cout << "add() = " << add(v) << endl;//add() = 11
		cout << "v = " << v << endl;//v = 10
	return 0;
}
//指針-修改形式參數(shù)會影響實(shí)際參數(shù)
int add(int* pValue)
{
	(*pValue)++;
	return *pValue;
}
int main()
{
	int v = 10;
	cout << "add() = " << add(&v) << endl;//add() = 11
	cout << "v = " << v << endl;//v = 11
	return 0;
}
//引用-修改形式參數(shù)會影響實(shí)際參數(shù)
int add(int &value)
{
	value++;
	return value;
}
int main()
{
	int v = 10;
	cout << "add() = " << add(v) << endl;//add() = 11
	cout << "v = " << v << endl;//v = 11
	return 0;
}

int sum(int a, int b=2)
{
  return (a + b);
}
int main ()
{
   cout << "Total value is :" << sum(100, 200);<< endl;//Total value is :300
   cout << "Total value is :" << sum(100);<< endl;//Total value is :102
   return 0;
}

函數(shù)名(實(shí)參列表);
show();

int a()
{
	return 666;
}
int b(int sum)
{
	return sum+a()
}
int main()
{
	cout<<b(222)<<endl;//888
	return 0;
}

//直接遞歸調(diào)用：求1+...n的值
int total(int sum)
{
	if (sum == 1)
	{
		return 1;
	}
	return sum + total(sum - 1);
}
int main()
{
	cout << "total = " << total(10) << endl;//total = 55
	system("pause");
	return 0;
}
//間接遞歸調(diào)用
int f2();
int f1()
{
...
  f2()
}
int f2()
{
	f1();
}

int add(int a,int b)
{
	return a+b;
}
double add(double a,double b)
{
	return a+b;
}
int add(int a,int b,int c)
{
	return a+b+c;
}

inline 函數(shù)類型 函數(shù)名(形參列表)
{
	函數(shù)體;
}
inline int add(int a, int b)
{
	return a + b;
}

#include <iostream>
#include <string>
using namespace std;
inline int add(int a, int b)
{
	return a + b;//斷點(diǎn)1
}
int main()
{
	int result = add(12, 34);
	cout << result << endl;//斷點(diǎn)2
	return 0;
}

...
		int result = add(12, 34);
00B620DE  mov         eax,0Ch  
00B620E3  add         eax,22h  //對eax中和22h中值進(jìn)行相加，賦值給eax
00B620E6  mov         dword ptr [result],eax  
		cout << result << endl;
00B620E9  mov         esi,esp  
00B620EB  push        offset std::endl<char,std::char_traits<char> > (0B610A5h)  
00B620F0  mov         edi,esp  
00B620F2  mov         eax,dword ptr [result]  
00B620F5  push        eax  
00B620F6  mov         ecx,dword ptr [_imp_?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A (0B6D098h)]  
00B620FC  call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (0B6D0A8h)]  
00B62102  cmp         edi,esp  
00B62104  call        __RTC_CheckEsp (0B611C7h)  
00B62109  mov         ecx,eax  
00B6210B  call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (0B6D0ACh)]  
00B62111  cmp         esi,esp  
00B62113  call        __RTC_CheckEsp (0B611C7h)   
		return 0;

int result = add(12, 34);
00291A4E  push        22h  
00291A50  push        0Ch  
00291A52  call        add (02914D8h)  //調(diào)用add函數(shù)
00291A57  add         esp,8//移動堆棧指針esp,繼續(xù)執(zhí)行主函數(shù)
00291A5A  mov         dword ptr [result],eax  
		cout << result << endl;
00291A5D  mov         esi,esp  
00291A5F  push        offset std::endl<char,std::char_traits<char> > (02910A5h)  
00291A64  mov         edi,esp  
00291A66  mov         eax,dword ptr [result]  
00291A69  push        eax  
00291A6A  mov         ecx,dword ptr [_imp_?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A (029D098h)]  
		cout << result << endl;
00291A70  call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (029D0A8h)]  
00291A76  cmp         edi,esp  
00291A78  call        __RTC_CheckEsp (02911C7h)  
00291A7D  mov         ecx,eax  
00291A7F  call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (029D0ACh)]  
00291A85  cmp         esi,esp  
00291A87  call        __RTC_CheckEsp (02911C7h)  
		system("pause");
00291A8C  mov         esi,esp  
00291A8E  push        offset string "pause" (0299B30h)  
00291A93  call        dword ptr [__imp__system (029D1DCh)]  
00291A99  add         esp,4  
00291A9C  cmp         esi,esp  
00291A9E  call        __RTC_CheckEsp (02911C7h)  
		return 0;

inline int add(int a, int b)
{
	int sum = 0;
	for (int i = 0; i < 100; i++)
		a++;
	for (int i = 0; i < 100; i++)
	{
		for (int i = 0; i < 100; i++)
		{
			sum++;
		}
	}
	return a + b;
}
int main()
{
	int result = add(12, 34);
	cout << result << endl;
	return 0;
}

int result = add(12, 34);
00181A4E  push        22h  
00181A50  push        0Ch  
00181A52  call        add (01814ECh)  ///
00181A57  add         esp,8  
00181A5A  mov         dword ptr [result],eax  
	cout << result << endl;
00181A5D  mov         esi,esp  
00181A5F  push        offset std::endl<char,std::char_traits<char> > (01810A5h)  
00181A64  mov         edi,esp  
00181A66  mov         eax,dword ptr [result]  
00181A69  push        eax  
00181A6A  mov         ecx,dword ptr [_imp_?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A (018D098h)]  
	cout << result << endl;
00181A70  call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (018D0A8h)]  
00181A76  cmp         edi,esp  
00181A78  call        __RTC_CheckEsp (01811C7h)  
00181A7D  mov         ecx,eax  
00181A7F  call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (018D0ACh)]  
00181A85  cmp         esi,esp  
00181A87  call        __RTC_CheckEsp (01811C7h)  
	return 0;
00181AA3  xor         eax,eax  

char a[5]
//字符個數(shù)不夠，補(bǔ)0; 字符個數(shù)超過報(bào)錯
char str[7] = {'h','e','i','r','e','n'};
char str[] = {'h','e','i','r','e','n'};
cin>>str;//輸入 輸入字符串長度一定小于已定義的字符數(shù)組長度
cout<<str;//輸出

strcat(char s1[],const char s2[]);//將s2接到s1上
strcpy(char s1[],const char s2[]);//將s2復(fù)制到s1上
strcmp(const char s1[],const char s2[]);//比較s1,s2 s1>s2返回1 相等返回1，否則返回-1
strlen(char s[]);//計(jì)算字符串s的長度 字符串s的實(shí)際長度，不包括\0在內(nèi)

//定義
string 變量;
string str1;
//賦值
string str2 = "ShangHai";
string str3 = str2;
str3[3] = '2';//對某個字符賦值
//字符串?dāng)?shù)組
string 數(shù)組名[常量表達(dá)式]
string arr[3];

#include <iostream>
#include <algorithm>
#include <string>
string str;//生成空字符串
string s(str);//生成字符串為str的復(fù)制品
string s(str, strbegin,strlen);//將字符串str中從下標(biāo)strbegin開始、長度為strlen的部分作為字符串初值
string s(cstr, char_len);//以C_string類型cstr的前char_len個字符串作為字符串s的初值
string s(num ,c);//生成num個c字符的字符串
string s(str, stridx);//將字符串str中從下標(biāo)stridx開始到字符串結(jié)束的位置作為字符串初值
size()和length();//返回string對象的字符個數(shù)
max_size();//返回string對象最多包含的字符數(shù)，超出會拋出length_error異常
capacity();//重新分配內(nèi)存之前，string對象能包含的最大字符數(shù)
>,>=,<,<=,==,!=//支持string與C-string的比較(如 str<”hello”)。  使用>,>=,<,<=這些操作符的時候是根據(jù)“當(dāng)前字符特性”將字符按字典順序進(jìn)行逐一得 比較，string (“aaaa”) <string(aaaaa)。    
compare();//支持多參數(shù)處理，支持用索引值和長度定位子串來進(jìn)行比較。返回一個整數(shù)來表示比較結(jié)果，返回值意義如下：0：相等 1：大于 -1：
push_back() 
insert( size_type index, size_type count, CharT ch );//在index位置插入count個字符ch
insert( size_type index, const CharT* s );//index位置插入一個常量字符串
insert( size_type index, const CharT* s, size_type n);//index位置插入常量字符串
insert( size_type index, const basic_string& str );//index位置插入常量string中的n個字符
insert( size_type index, const basic_string& str, size_type index_str, size_type n);//index位置插入常量str的從index_str開始的n個字符
insert( size_type index, const basic_string& str,size_type index_str, size_type count = npos);//index位置插入常量str從index_str開始的count個字符，count可以表示的最大值為npos.這個函數(shù)不構(gòu)成重載 npos表示一個常數(shù)，表示size_t的最大值，string的find函數(shù)如果未找到指定字符，返回的就是一個npos
iterator insert( iterator pos, CharT ch );
iterator insert( const_iterator pos, CharT ch );
void insert( iterator pos, size_type n, CharT ch );//迭代器指向的pos位置插入n個字符ch
iterator insert( const_iterator pos, size_type count, CharT ch );//迭代器指向的pos位置插入count個字符ch
void insert( iterator pos, InputIt first, InputIt last );
iterator insert( const_iterator pos, InputIt first, InputIt last );
append() 和 + 操作符
//訪問string每個字符串
string s1("yuanrui"); // 調(diào)用一次構(gòu)造函數(shù)
// 方法一： 下標(biāo)法
for( int i = 0; i < s1.size() ; i++ )
     cout<<s1[i];
// 方法二：正向迭代器
for( string::iterator iter = s1.begin();; iter < s1.end() ; iter++)
     cout<<*iter;
 // 方法三：反向迭代器
for(string::reverse_iterator riter = s1.rbegin(); ; riter < s1.rend() ; riter++)
     cout<<*riter;
 iterator erase(iterator p);//刪除字符串中p所指的字符
iterator erase(iterator first, iterator last);//刪除字符串中迭代器區(qū)間[first,last)上所有字符
string& erase(size_t pos = 0, size_t len = npos);//刪除字符串中從索引位置pos開始的len個字符
void clear();//刪除字符串中所有字符
string& replace(size_t pos, size_t n, const char *s);//將當(dāng)前字符串從pos索引開始的n個字符，替換成字符串s
string& replace(size_t pos, size_t n, size_t n1, char c); //將當(dāng)前字符串從pos索引開始的n個字符，替換成n1個字符c
string& replace(iterator i1, iterator i2, const char* s);//將當(dāng)前字符串[i1,i2)區(qū)間中的字符串替換為字符串s
//tolower()和toupper()函數(shù) 或者 STL中的transform算法
string s = "ABCDEFG";
for( int i = 0; i < s.size(); i++ )
     s[i] = tolower(s[i]);
transform(s.begin(),s.end(),s.begin(),::tolower);
size_t find (constchar* s, size_t pos = 0) const;//在當(dāng)前字符串的pos索引位置開始，查找子串s，返回找到的位置索引，-1表示查找不到子串
size_t find (charc, size_t pos = 0) const;//在當(dāng)前字符串的pos索引位置開始，查找字符c，返回找到的位置索引，-1表示查找不到字符
size_t rfind (constchar* s, size_t pos = npos) const;//在當(dāng)前字符串的pos索引位置開始，反向查找子串s，返回找到的位置索引，-1表示查找不到子串
size_t rfind (charc, size_t pos = npos) const;//在當(dāng)前字符串的pos索引位置開始，反向查找字符c，返回找到的位置索引，-1表示查找不到字符
size_tfind_first_of (const char* s, size_t pos = 0) const;//在當(dāng)前字符串的pos索引位置開始，查找子串s的字符，返回找到的位置索引，-1表示查找不到字符
size_tfind_first_not_of (const char* s, size_t pos = 0) const;//在當(dāng)前字符串的pos索引位置開始，查找第一個不位于子串s的字符，返回找到的位置索引，-1表示查找不到字符
size_t find_last_of(const char* s, size_t pos = npos) const;//在當(dāng)前字符串的pos索引位置開始，查找最后一個位于子串s的字符，返回找到的位置索引，-1表示查找不到字符
size_tfind_last_not_of (const char* s, size_t pos = npos) const;//在當(dāng)前字符串的pos索引位置開始，查找最后一個不位于子串s的字符，返回找到的位置索引，-1表示查找不到子串
sort(s.begin(),s.end());
substr(pos,n);//返回字符串從下標(biāo)pos開始n個字符
strtok()
char str[] = "I,am,a,student; hello world!";
const char *split = ",; !";
char *p2 = strtok(str,split);
while( p2 != NULL )
{
    cout<<p2<<endl;
    p2 = strtok(NULL,split);
}

數(shù)據(jù)類型 *指針變量名;
int    *ip;    //整型的指針 
double *dp;    //double 型的指針 
float  *fp;    //浮點(diǎn)型的指針 
char   *ch;    //字符型的指針 

數(shù)據(jù)類型 *指針變量名 = &變量名;
*指針變量名 = &變量名;
int a;
int *p = &a;
int *p2;
p2 = &a;

int x = 3;
int y;
int *p;
p = &x;
y = *p;//y = a

int arr[10],len;
int *p1 = &arr[2],*p2 = &arr[5];
 len = p2-p1;//arr[2] 和arr[5]之間的元素個數(shù) 3

指針變量 = new 數(shù)據(jù)類型(初值);
delete 指針變量;
delete[] 指針變量;//釋放為多個變量分配的地址
int *ip;
ip= new int(1);
delete ip;
int *ip;
 ip= new int[10];
 for (int i = 0; i < 10;i++)
 {
	 ip[i] = i;
 }
 delete[] ip;
int a[3][4] = {0};

int arr[10];
int *p1 = arr;// *p1 = &arr[0];
int a[3][5] = { 0 };
int(*ap)[5];
ap = a;
ap+1;//表示下一個一維數(shù)組

int a;
int &b = a;//a和b表示相同的變量，具有相同的地址。

void swap(int &r1, int &r2) {
    int temp = r1;
    r1 = r2;
    r2 = temp;
}
int &add1(int &r) {
	r += 1;
	return r;
}
int main()
{
	int a = 12;
	int b = add1(a);
	cout << a << "   "<<b << endl;//13  13
	return 0;
}

int &add1(int &r) {
	r += 1;
	int res = r;
	return res;
}
void test()
{
	int xx = 123;
	int yy = 66;
}
int main()
{
	int a = 12;
	int &b = add1(a);
	int &c = add1(a);
	test();//函數(shù)調(diào)用，覆蓋之前函數(shù)的局部數(shù)據(jù)
	cout << a << "   "<<b <<" "<< c<<endl;//14   -858993460 -858993460
	return 0;
}

struct 結(jié)構(gòu)體類型名
{
	成員類型1 成員名1;
	成員類型2 成員名2;
	... ...
	成員類型n 成員名n;
};

//定義結(jié)構(gòu)體同時聲明結(jié)構(gòu)體變量名
struct 結(jié)構(gòu)體類型名
{
	成員類型1 成員名1;
	成員類型2 成員名2;
	... ...
	成員類型n 成員名n;
}變量名1,變量名2,...變量名n;
//先定義結(jié)構(gòu)體
[struct] 結(jié)構(gòu)體類型名 變量名;
//直接定義
struct 
{
	成員類型1 成員名1;
	成員類型2 成員名2;
	... ...
	成員類型n 成員名n;
}變量名1,變量名2,...變量名n;
struct  person
{
	int year;
	int age;
	string name;
}p1 = {2019,24,"heiren"}, p1 = { 2020,24,"heiren" };
struct  person
{
	int year;
	int age;
	string name;
};
struct person p1 = { 2019,24,"heiren" }, p1 = { 2020,24,"heiren" };
struct 
{
	int year;
	int age;
	string name;
}p1 = {2019,24,"heiren"}, p1 = { 2020,24,"heiren" };

struct person
{
	int year;
	int age;
	string name;
}p[2] ={ {2019,24,"heiren"}, { 2020,24,"heiren" }};//可以不指定數(shù)組元素個數(shù)
p[1].age;

//指定對齊值=8
struct st 
{
	// 空結(jié)構(gòu)體大小1
	char c1;//1
	char c2;//2
	int i1;//8  int  起始地址按照字節(jié)對齊的原理應(yīng)該是它長度4的整數(shù)倍
	char c3;//12
	short s4;//12 short 起始地址按照字節(jié)對齊的原理應(yīng)該是它長度2的整數(shù)倍 12 + 2 = 12
	double d;//24 double 起始地址按照字節(jié)對齊的原理應(yīng)該是它長度8的整數(shù)倍 12->16 + 8 = 24
	char c4;//32   24 + 4 = 28 結(jié)構(gòu)體的總大小為8的整數(shù)倍 28->32
	int i2;//32  28+4 = 32
	int i3;//40   
	short s5;//40
};
cout << sizeof(st) << endl;//40
//指定對齊值=4
#pragma  pack(4)
struct st
{
	//1 空結(jié)構(gòu)體大小1
	char c1;//1
	char c2;//2
	int i1;//8
	char c3;//12
	short s4;//12
	double d;//20
	char c4;//24
	int i2;//28
	int i3;//32
	short s5;//36
}s;
cout << sizeof(st) << endl;//36

union 共同體類型名
{
    成員類型1 成員名1;
	成員類型2 成員名2;
	... ...
	成員類型n 成員名n;
};

union data
{
	int i;
	float f;
	char c;
}x = {123};
union data
{
	float f;
	int i;
	char c;
};
data x = {12.3};
union 
{
	char c;
	int i;
	float f;
}x = {'y‘};

共同體變量名.成員名;
union data
{
	int i;
	float f;
	char c;
}x = {12};
int main()
{
	cout << x.i << " " << x.f << " " << x.c << endl;//12 1.68156e-44 
	x.c = 'c';
	cout << x.i <<" "<< x.f << " " << x.c << endl;//99 1.38729e-43 c
	return 0;
}

typedef char *CP;
typedef int INTEGER;

class 類名
{
	public:
		公有數(shù)據(jù)成員;
		公有成員函數(shù);
	private:
		私有數(shù)據(jù)成員;
		私有成員函數(shù);
	protected:
		保護(hù)數(shù)據(jù)成員;
		保護(hù)成員函數(shù);
};

//類外
返回類型 類名:成員函數(shù)名(參數(shù)列表)
{
	函數(shù)體;
}
//內(nèi)聯(lián)函數(shù)：類外
inline 返回類型 類名:成員函數(shù)名(參數(shù)列表)
{
	函數(shù)體;
}

//1.聲明類同時定義對象
class 類名
{
	類體;
}對象名列表;
//2.先聲明類，再定義對象
類名 對象名(參數(shù)列表);//參數(shù)列表為空時，()可以不寫
//3. 不出現(xiàn)類名，直接定義對象
class 
{
	類體;
}對象名列表;
//4.在堆上創(chuàng)建對象
Person p(123, "yar");//在棧上創(chuàng)建對象
Person *pp = new Person(234,"yar");//在堆上創(chuàng)建對象

//1.類中定義 2.類中聲明，類外定義
[類名::]構(gòu)造函數(shù)名(參數(shù)列表)
{
	函數(shù)體
}

class Person
{
public:
	Person(int = 0,string = "張三");
	void show();
private:
	int age;
	string name;
};
Person::Person(int a, string s)
{
	cout<<a<<" "<<s<<endl;
	age = a;
	name = s;
}
void Person::show()
{
	cout << "age="<<age << endl;
	cout << "name=" <<name << endl;
}
int main()
{
     Person p; //0 張三
	Person p2(12);//12 張三
	Person p3(123, "yar");//123 yar
	return 0;
}

類名::構(gòu)造函數(shù)名(參數(shù)列表):參數(shù)初始化表
{
	函數(shù)體;
}
參數(shù)初始化列表的一般形式：
參數(shù)名1(初值1),參數(shù)名2(初值2),...,參數(shù)名n(初值n)
class Person
{
public:
	Person(int = 0,string = "張三");
	void show();
private:
	int age;
	string name;
};
Person::Person(int a, string s):age(a),name(s)
{
	cout << a << " " << s << endl;
}

class Person
{
public:
	Person();
	Person(int = 0,string = "張三");
	Person(double,string);
	void show();
private:
	int age;
	double height;
	string name;
};
...

類名::類名(類名&對象名)
{
	函數(shù)體;
}
class Person
{
public:
	Person(Person &p);//聲明拷貝構(gòu)造函數(shù)
	Person(int = 0,string = "張三");
	void show();
private:
	int age;
	string name;
};
Person::Person(Person &p)//定義拷貝構(gòu)造函數(shù)
{
	cout << "拷貝構(gòu)造函數(shù)" << endl;
	age = 0;
	name = "ABC";
}
Person::Person(int a, string s):age(a),name(s)
{
	cout << a << " " << s << endl;
}
int main()
{
	Person p(123, "yar");
	Person p2(p);
	p2.show();
	return 0;
}
//輸出
123 yar
拷貝構(gòu)造函數(shù)
age=0
name=ABC

//1.類中定義 2.類中聲明，類外定義
[類名::]~析構(gòu)函數(shù)名()
{
	函數(shù)體;
}

類名 *對象指針名;
對象指針 = &對象名;
//訪問對象成員
對象指針->數(shù)據(jù)成員名
對象指針->成員函數(shù)名(參數(shù)列表)
Person p(123, "yar");
Person* pp = &p;
Person* pp2 = new Person(234,"yar")
pp->show();

數(shù)據(jù)成員類型 *指針變量名 = &對象名.數(shù)據(jù)成員名;
函數(shù)類型 (類名::*指針變量名)(參數(shù)列表);
指針變量名=&類名::成員函數(shù)名;
(對象名.*指針變量名)(參數(shù)列表);
Person p(123, "yar");
void(Person::*pfun)();
pfun = &Person::show;
(p.*pfun)();

class Person
{
public:
	Person(int = 0,string = "張三");
	void show();
private:
	int age;
	string name;
};
Person::Person(int a, string s):age(a),name(s)
{
	cout << a << " " << s << endl;
}
void Person::show()
{
	cout << "age="<<this->age << endl;
	cout << "name=" <<this->name << endl;
}

//類內(nèi)聲明，類外定義
class xxx
{
	static 數(shù)據(jù)類型 靜態(tài)數(shù)據(jù)成員名;
}
數(shù)據(jù)類型 類名::靜態(tài)數(shù)據(jù)成員名=初值
//訪問
類名::靜態(tài)數(shù)據(jù)成員名;
對象名.靜態(tài)數(shù)據(jù)成員名;
對象指針名->靜態(tài)數(shù)據(jù)成員名;

//類內(nèi)聲明，類外定義
class xxx
{
	static 返回值類型 靜態(tài)成員函數(shù)名(參數(shù)列表);
}
返回值類型 類名::靜態(tài)成員函數(shù)名(參數(shù)列表)
{
	函數(shù)體;
}
//訪問
類名::靜態(tài)成員函數(shù)名(參數(shù)列表);
對象名.靜態(tài)成員函數(shù)名(參數(shù)列表);
對象指針名->靜態(tài)成員函數(shù)名(參數(shù)列表);

//1.將非成員函數(shù)聲明為友元函數(shù)
class Person
{
public:
	Person(int = 0,string = "張三");
	friend void show(Person *pper);//將show聲明為友元函數(shù)
private:
	int age;
	string name;
};
Person::Person(int a, string s):age(a),name(s)
{
	cout << a << " " << s << endl;
}
void show(Person *pper)
{
	cout << "age="<< pper->age << endl;
	cout << "name=" << pper->name << endl;
}
int main()
{;
	Person *pp = new Person(234,"yar");
	show(pp);
	system("pause");
	return 0;
}
//2.將其他類的成員函數(shù)聲明為友元函數(shù)
//person中的成員函數(shù)可以訪問MobilePhone中的私有成員變量
class MobilePhone;//提前聲明
//聲明Person類
class Person
{
public:
	Person(int = 0,string = "張三");
	void show(MobilePhone *mp);
private:
	int age;
	string name;
};
//聲明MobilePhone類
class MobilePhone
{
public:
	MobilePhone();
	friend void Person::show(MobilePhone *mp);
private:
	int year;
	int memory;
	string name;
};
MobilePhone::MobilePhone()
{
	year = 1;
	memory = 4;
	name = "iphone 6s";
}
Person::Person(int a, string s):age(a),name(s)
{
	cout << a << " " << s << endl;
}
void Person::show(MobilePhone *mp)
{
	cout << mp->year << "年  " << mp->memory << "G " << mp->name << endl;
}
int main()
{
	Person *pp = new Person(234,"yar");
	MobilePhone *mp = new MobilePhone;
	pp->show(mp);
	system("pause");
	return 0;
}

class HardDisk
{
public:
	HardDisk();
	friend class Computer;
private:
	int capacity;
	int speed;
	string brand;
};
HardDisk::HardDisk():capacity(128),speed(0),brand("三星"){
}
class Computer
{
public:
	Computer(HardDisk hd);
	void start();
private:
	string userName;
	string name;
	int ram;
	string cpu;
	int osType;
	HardDisk hardDisk;
};
Computer::Computer(HardDisk hd):userName("yar"),name("YAR-PC"),ram(16),cpu("i7-4710"),osType(64)
{
	cout << "正在創(chuàng)建computer..." << endl;
	this->hardDisk = hd;
	this->hardDisk.speed = 5400;
	cout << "硬盤轉(zhuǎn)動...speed = " << this->hardDisk.speed << "轉(zhuǎn)/分鐘" << endl;
}
void Computer::start()
{
	cout << hardDisk.brand << " " << hardDisk.capacity << "G" << hardDisk.speed << "轉(zhuǎn)/分鐘" << endl;
	cout << "筆記本開始運(yùn)行..." << endl;
}
int main()
{
	HardDisk hd;
	Computer cp(hd);
	cp.start();
	system("pause");
	return 0;
}

//結(jié)構(gòu)體默認(rèn)權(quán)限為public
struct person
{
	void show();
	string name;
	int age;
};
int main()
{
	person p;
	p.name = "heiren";
	p.age = 666;
	p.show();
	cout <<"name="<< p.name <<" age="<< p.age << endl;
	system("pause");
	return 0;
}

//繼承方式為可選項(xiàng)，默認(rèn)為private，還有public,protected
class 派生類名：[繼承方式]基類名
{
	派生類新增加的成員聲明;
};

class Base
{
public:
	void show();
protected:
	int aa;
	double dd;
};
void Base::show(){
}
class Person:public Base
{
public:
	using Base::aa;//將基類的protected成員變成public
	using Base::dd;//將基類的protected成員變成public
private:
	using Base::show;//將基類的public成員變成private
	string name;
};
int main()
{
	Person *p = new Person();
	p->aa = 12;
	p->dd = 12.3;
	p->show();//出錯
	delete p;
	return 0;
}

class Base
{
public:
	Base(int, double);
	~Base();
private:
	int aa;
	double dd;
};
Base::Base(int a, double d) :aa(a), dd(d)
{
	cout << "Base Class 構(gòu)造函數(shù)!!!" << endl;
}
Base::~Base()
{
	cout << "Base Class 析構(gòu)函數(shù)!!!" << endl;
}
class Person:public Base
{
public:
	Person(int,double,string);
	~Person();
private:
	string name;
};
Person::Person(int a,double d,string str):Base(a,d),name(str)
{
	cout << "Person Class 構(gòu)造函數(shù)!!!" << endl;
}
Person::~Person()
{
	cout << "Person Class 析構(gòu)函數(shù)!!!" << endl;
}
int main()
{
	cout << "創(chuàng)建Person對象..." << endl;
	Person *p = new Person(1,2,"yar");
	cout << "刪除Person對象...." << endl;
	delete p;
	system("pause");
	return 0;
}

class 派生類名:繼承方式1 基類1,繼承方式2 基類2
{
	派生類主體;
};

派生類名(總參數(shù)列表)：基類名1(基類參數(shù)列表1),基類名2(基類參數(shù)列表2),
子對象名1,...(參數(shù)列表)
{
	構(gòu)造函數(shù)體;
}`

class  A//虛基類
{
protected:
	int a;
};
class B: virtual public A
{
protected:
	int b;
};
class C:virtual public A
{
protected:
	int c;
};
class D:public B,public C
{
protected:
	int d;
	void show()
	{
		b = 123;
		c = 23;
		a = 1;
	}
};

int a = 66.9;
printf("%d\n", a);//66
float b = 66;
printf("%f\n", b);//66.000000

class  A
{
public:
	virtual void show()
	{
		cout << "A show" << endl;
	}
};
class B:  public A
{
public:
	void show()
	{
		cout << "B show" << endl;
	}
};
int main()
{
	B b;
	b.show();//B show
	A *pA = &b;
	pA->show();//B show 如果show方法前沒用virtual聲明為虛函數(shù)，這里會輸出A show
	system("pause");
	return 0;
}

class  A
{
public:
	virtual void show() = 0;
};
class B:  public A
{
public:
	void show()
	{
		cout << "B show" << endl;
	}
};

函數(shù)類型 operator運(yùn)算符(參數(shù)列表)
{
	函數(shù)體
}
//舉個栗子：定義一個向量類，通過運(yùn)算符重載，可以用+進(jìn)行運(yùn)算。
class Vector3
{
public:
	Vector3();
	Vector3(double x,double y,double z);
public:
	Vector3 operator+(const Vector3 &A)const;
	void display()const;
private:
	double m_x;
	double m_y;
	double m_z;
};
Vector3::Vector3() :m_x(0.0), m_y(0.0), m_z(0.0) {}
Vector3::Vector3(double x, double y,double z) : m_x(x), m_y(y), m_z(z) {}
//運(yùn)算符重載
Vector3 Vector3::operator+(const Vector3 &A) const
{
	Vector3 B;
	B.m_x = this->m_x + A.m_x;
	B.m_y = this->m_y + A.m_y;
	B.m_z = this->m_z + A.m_z;
	return B;
}
void  Vector3::display()const
{
	cout<<"(" << m_x << "," << m_y << "," << m_z << ")" << endl;
}

class Vector3
{
public:
	Vector3();
	Vector3(double x,double y,double z);
public:
	Vector3 operator+(const Vector3 &A)const;
	Vector3 operator++();
	friend Vector3 operator-(const Vector3 &v1, const Vector3 &v2);
	friend Vector3 operator--(Vector3 &v);
	void display()const;
private:
	double m_x;
	double m_y;
	double m_z;
};
Vector3::Vector3() :m_x(0.0), m_y(0.0), m_z(0.0) {}
Vector3::Vector3(double x, double y,double z) : m_x(x), m_y(y), m_z(z) {}
//運(yùn)算符重載
Vector3 Vector3::operator+(const Vector3 &A) const
{
	Vector3 B;
	B.m_x = this->m_x + A.m_x;
	B.m_y = this->m_y + A.m_y;
	B.m_z = this->m_z + A.m_z;
	return B;
}
Vector3 Vector3::operator++()
{
	this->m_x ++;
	this->m_y ++;
	this->m_z ++;
	return *this;
}
void  Vector3::display()const
{
	cout<<"(" << m_x << "," << m_y << "," << m_z << ")" << endl;
}
Vector3 operator-(const Vector3 &v1,const Vector3 &v2)
{
	Vector3 B(v1.m_x - v2.m_x, v1.m_y - v2.m_y, v1.m_z - v2.m_z);
	return B;
}
Vector3 operator--( Vector3 &v)
{
	v.m_x--;
	v.m_y--;
	v.m_z --;
	return v;
}
int main()
{
	Vector3 v1(1, 2, 3);
	Vector3 v2(2, 3, 2);
	++v1;//v1.operator++(); 作為類成員函數(shù)可以顯式調(diào)用
	v1.display();
	--v2;
	v2.display();
	Vector3 v3 = v1 + v2;// v1.operator+(v2);作為類成員函數(shù)可以顯式調(diào)用
	v3.display();
	Vector3 v4 = v1 - v2;
	v4.display();
	return 0;
}

//前置運(yùn)算符 ++a --a
operator++()
operator--()
operator++(Vector3 &v)
operator--(Vector3 &v)
//后置運(yùn)算符 a-- a++
operator++(int)
operator--(int)
operator++(Vector3 &v,int)
operator--(Vector3 &v,int)

String& String::operator=(String &s)
{
  if(this!=&s)
  {
  		delete[] str;
  		int length = strlen(s.str);
  		str = new char[length+1];
  		strcpy(str,s.str);
  }
  return (*this)
}

 friend ostream &operator<<( ostream &output, 
                                       const Vector3 &v )
      { 
         output << "F : " <<v.m_x<< " I : " << v.m_y<<v.m_z;
         return output;            
      }
      friend istream &operator>>( istream  &input, Vector3 &v )
      { 
         input >> v.m_x>> v.m_y>>v.m_z;
         return input;            
      }

operator 類型名()
{
	轉(zhuǎn)換語句;
}
class Vector3
{
public:
	Vector3();
	Vector3(double x,double y,double z);
public:
	Vector3 operator+(const Vector3 &A)const;
	Vector3 operator++();
	friend Vector3 operator-(const Vector3 &v1, const Vector3 &v2);
	friend Vector3 operator--(Vector3 &v,int);
	operator double()
	{
		return m_x + m_y + m_z;
	}
	void display()const;
private:
	double m_x;
	double m_y;
	double m_z;
};
int main()
{
	Vector3 v1(1, 2, 3);
	double d = v1;
	cout << d << endl;//6
	return 0;
}

int  x;
double y;
cin>>x>>y;
//輸入 22 66.0  兩個數(shù)之間可以用空格、制表符和回車分隔數(shù)據(jù)
char str[10];
cin>>str;//hei ren  字符串中只有hei\0

char c = cin.get();//獲取一個字符
while ((c = cin.get()) != EOF)//循環(huán)讀取，直到換行
{
	cout << c;
}
char ch;
cin.get(ch);
while (cin.get(ch))//讀取成功循環(huán)
{
	cout << ch;
}
char arr[5];
cin.get(arr, 5, '\n');//輸入 heiren  結(jié)果 heir\0

char arr0[30],arr1[30],arr2[40];
cin>>arr0;//遇到空格、制表符或回車結(jié)束  "Heiren"
cin.getline(arr1,30);//字符數(shù)最多為29個，遇到回車結(jié)束 " Hello World"
cin.getline(arr2,40,'*');//最多為39個，遇到*結(jié)束 "yar"
//輸入 Heiren Hello World
//yar*123

int n;
 cin.ignore(5, 'Y');//跳過前5個字符或Y之前的字符，‘Y'優(yōu)先
 cin >> n;
 //輸入1234567  ->  67    1234567Y345->345
//輸入2020.2.23
int year,month,day;
cin >> year ;
cin.ignore() >> month ; //用ignore跳過 '.'
 cin.ignore() >> day;
cin.ignore();   //跳過行末 '\n'
 cout<< setfill('0') << setw(2) << month ;//設(shè)置填充字符'\0'，輸出寬度2
 cout << "-" << setw(2) << day << "-" << setw(4) << year << endl;

cout << setiosflags(ios::fixed) << 12.34 << endl;
cout << resetiosflags(ios::fixed) << setiosflags(ios::scientific | ios::showpos) << 12.34 << endl;

cout.setf(ios::scientific);
cout.precision(8);
cout << 12.23 << endl;//1.22300000e+001

#include <fstream>
ifstream in;
ofstream out;
fstream inout;

#include <iostream>
#include <fstream>
using namespace std;
int main()
{
    ifstream inFile("c:\\tmp\\test.txt", ios::in);
    if (inFile)
        inFile.close();
    else
        cout << "test.txt doesn't exist" << endl;
    ofstream oFile("test1.txt", ios::out);
    if (!oFile)
        cout << "error 1";
    else
        oFile.close();
    fstream oFile2("tmp\\test2.txt", ios::out | ios::in);
    if (!oFile2)
        cout << "error 2";
    else
        oFile.close();
    return 0;
}

#include <iostream>
#include <fstream>
using namespace std;
int arr[100];
int main()
{
	int num = 0;
	ifstream inFile("i.txt", ios::in);//文本模式打開
	if (!inFile)
		return 0;//打開失敗
	ofstream outFile("o.txt",ios::out);
	if (!outFile)
	{
		outFile.close();
		return 0;
	}
	int x;
	while (inFile >> x)
		arr[num++] = x;
	for (int i = num - 1; i >= 0; i--)
		outFile << arr[i] << " ";
	inFile.close();
	outFile.close();
	return 0;
}

class Person
{
public:
	char m_name[20];
	int m_age;
};
int main()
{
	Person p;
	ofstream outFile("o.bin", ios::out | ios::binary);
	while (cin >> p.m_name >> p.m_age)
		outFile.write((char*)&p, sizeof(p));//強(qiáng)制類型轉(zhuǎn)換
	outFile.close();
	//heiren 燙燙燙燙燙燙啼  
	return 0;
}

Person p;
ifstream inFile("o.bin", ios::in | ios::binary); //二進(jìn)制讀方式打開
if (!inFile)
	return 0;//打開文件失敗
while (inFile.read((char *)&p, sizeof(p)))
	cout << p.m_name << " " << p.m_age << endl;
inFile.close();

#include <iostream>
#include <fstream>
using namespace std;
int main()
{
    ifstream inFile("a.txt", ios::binary | ios::in); 
    if (!inFile)
        return 0;
    ofstream outFile("b.txt", ios::binary | ios::out);
    if (!outFile) 
    {
        inFile.close();
        return 0;
    }
    char c;
    while (inFile.get(c))  //每讀一個字符
        outFile.put(c);  //寫一個字符
    outFile.close();
    inFile.close();
    return 0;
}

ostream & seekp (int offset, int mode);
istream & seekg (int offset, int mode);
//mode有三種：ios::beg-開頭往后offset(>=0)字節(jié) ios::cur-當(dāng)前往前(<=0)/后(>=0)offset字節(jié) ios::end-末尾往前(<=0)offect字節(jié)
int tellg();
int tellp();
//seekg 函數(shù)將文件讀指針定位到文件尾部，再用 tellg 函數(shù)獲取文件讀指針的位置，此位置即為文件長度

#include <iostream>
#include <fstream>
//#include <vector>
//#include<cstring>
using namespace std;
class Person
{
public:
	char m_name[20];
	int m_age;
};
int main()
{
	Person p;
	ifstream ioFile("p.bin", ios::in | ios::out);//用既讀又寫的方式打開
	if (!ioFile) 
		return 0;
	ioFile.seekg(0, ios::end); //定位讀指針到文件尾部，以便用以后tellg 獲取文件長度
	int L = 0, R; // L是折半查找范圍內(nèi)第一個記錄的序號
				  // R是折半查找范圍內(nèi)最后一個記錄的序號
	R = ioFile.tellg() / sizeof(Person) - 1;
	do {
		int mid = (L + R) / 2; 
		ioFile.seekg(mid *sizeof(Person), ios::beg); 
		ioFile.read((char *)&p, sizeof(p));
		int tmp = strcmp(p.m_name, "Heiren");
		if (tmp == 0)
		{ 
			cout << p.m_name << " " << p.m_age;
			break;
		}
		else if (tmp > 0) 
			R = mid - 1;
		else  
			L = mid + 1;
	} while (L <= R);
	ioFile.close();
	system("pause");
	return 0;
}

template<class T>或template<typename T>
函數(shù)類型 函數(shù)名(參數(shù)列表)
{
	函數(shù)體;
}
template<class T1,class T2,...>//class可以換成typename
函數(shù)類型 函數(shù)名(參數(shù)列表)
{
	函數(shù)體;
}
//舉個栗子
template<class T> T max(T a, T b)
{
	return a > b ? a : b;
}
int main()
{
	cout <<"max value is "<< max(12,34) << endl;//34
	cout << "max value is " << max(12.4, 13.6) << endl;//13.6
	cout << "max value is " << max(12.4, 13) << endl;//error 沒有與參數(shù)列表匹配的 函數(shù)模板 "max" 實(shí)例參數(shù)類型為:(double, int)
	return 0;
}

template<class T>//class可以換成typename 模板頭
class 類名
{
	函數(shù)定義;
};
//多個類型參數(shù)和函數(shù)模板類似，逗號隔開

template<typename T1, typename T2>  // 模板頭  沒有分號
class Point {
public:
	Point(T1 x, T2 y) : x(x), y(y) { }
public:
	T1 getX() const;  //成員函數(shù)后加const，聲明該函數(shù)內(nèi)部不會改變成員變量的值
	void setX(T1 x);  
	T2 getY() const;  
	void setY(T2 y);  
private:
	T1 x;  
	T2 y;  
};
template<typename T1, typename T2>  //模板頭
T1 Point<T1, T2>::getX() const  {
	return x;
}
template<typename T1, typename T2>
void Point<T1, T2>::setX(T1 x) {
	x = x;
}
template<typename T1, typename T2>
T2 Point<T1, T2>::getY() const {
	return y;
}
template<typename T1, typename T2>
void Point<T1, T2>::setY(T2 y) {
	y = y;
}
int main()
{
	Point<int, double> p1(66, 20.5);
	Point<int, char*> p2(10, "東經(jīng)33度");
	Point<char*, char*> *p3 = new Point<char*, char*>("西經(jīng)12度", "北緯66度");
	cout << "x=" << p1.getX() << ", y=" << p1.getY() << endl;
	cout << "x=" << p2.getX() << ", y=" << p2.getY() << endl;
	cout << "x=" << p3->getX() << ", y=" << p3->getY() << endl;
	return 0;
}

class MyClass
{
public:
		typedef int LengthType;
		LengthType getLength() const
		{
			return this->length;
		}
		void setLength(LengthType length)
		{
			this->length = length;
		}
private:
	LengthType length;
};
template<class T>
void MyMethod(T myclass)
{
	//告訴 c++ 編譯器，typename 后面的字符串為一個類型名稱，而不是成員函數(shù)或者成員變量
	typedef typename T::LengthType LengthType; //
	LengthType length = myclass.getLength();
	cout << "length = " <<length<< endl;
}
int main()
{
	MyClass my;
	my.setLength(666);
	MyMethod(my);//length = 666
	return 0;
}

int a = 123;  //不轉(zhuǎn)換
a = 12.89;  //隱式轉(zhuǎn)換 12（舍去小數(shù)部分）
a = (int)"heiren,HelloWorld";  //強(qiáng)制轉(zhuǎn)換（得到字符串的地址） 不同類型之間轉(zhuǎn)換需要強(qiáng)制

//Java 對類型轉(zhuǎn)換的要求比 C/C++ 更為嚴(yán)格，隱式轉(zhuǎn)換只允許由低向高轉(zhuǎn)，由高向低轉(zhuǎn)必須強(qiáng)制轉(zhuǎn)換。
int a = 100;  //不轉(zhuǎn)換
a = (int)12.34;  //強(qiáng)制轉(zhuǎn)換（直接舍去小數(shù)部分，得到12）

var a = 100;  //賦給整數(shù)
a = 12.34;  //賦給小數(shù)
a = "heiren,HelloWorld";  //賦給字符串
a = new Array("JavaScript","React","JSON");  //賦給數(shù)組

namespace [命名空間名]//名省略時，表示無名的命名空間
{
	命名空間成員;
}

try
{
	被檢查的語句（可以有多個throw語句）;
}
catch(異常信息類型 [變量名])
{
}

try
{
	throw 123;
}
catch (int a)
{
	cout << a << endl;//123
}

int size();
bool empty();

begin()
end()
rbegin()
erase(...)
clear()

front()
back()
push_back();
pop_back();
insert(...);

#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
int main()  {
   vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4); //1,2,3,4
	vector<int>::iterator p;
	p = find(v.begin(), v.end(), 3); //在v中查找3 若找不到,find返回 v.end()
	if (p != v.end())
		cout << "1) " << *p << endl; //找到了
	p = find(v.begin(), v.end(), 9);
	if (p == v.end())
		cout << "not found " << endl; //沒找到
	p = find(v.begin() + 1, v.end() - 1, 4); //在2,3 這兩個元素中查找4
	cout << "2) " << *p << endl; //沒找到，指向下一個元素4
	int arr[10] = { 10,20,30,40 };
	int * pp = find(arr, arr + 4, 20);
	if (pp == arr + 4)
		cout << "not found" << endl;
	else
		cout << "3) " << *pp << endl;
	return 0;
}