update

practical_exercises/10_day_practice/day1/打印练习.cpp

@@ -0,0 +1,24 @@
+#include<iostream>
+using namespace std;
+int main(int argc, char const *argv[])
+{
+    int i,j,k,f;
+    for (i=1;i<=4;i++){
+        for (j=1;j<=30;j++)
+            cout<<" ";
+        for (k=1;k<=8-2*i;k++)
+            cout<<" ";
+        for (f=1;f<=2*i;f++)
+            cout<<'*';
+        cout<<endl;
+    }
+    for(i=1;i<=3;i++){
+        for (j=1;j<=30;j++)
+            cout<<" ";
+        for (f=1;f<=7-2*i;f++)
+            cout<<'*';
+        cout<<endl;
+    }
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day1/是否闰年‘.cpp

@@ -0,0 +1,20 @@
+#include<iostream>
+using namespace std;
+int main(int argc, char const *argv[])
+{
+    int year;
+    bool isLeapYear;
+    cout<<"Enter the year: ";
+    cin>>year;
+    isLeapYear = (((year%4==0)&&(year%100!=0))||(year%400==0));
+    if(isLeapYear)
+    {
+        cout<<year<<" is a leap year"<<endl;
+    }
+    else
+    {
+        cout<<year<<" is not a leap year"<<endl;
+    }
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day1/注释.cpp

@@ -0,0 +1,16 @@
+#include<iostream>
+
+
+一种条件编译指令注释
+
+
+//另一种注释方法
+#if 0
+asd
+#endif
+
+//打开注释
+//条件编译指令
+#if 1
+asData
+#endif

practical_exercises/10_day_practice/day1/联合体学习.cpp

@@ -0,0 +1,18 @@
+#include<iostream>
+using namespace std;
+//相同的内存地址
+union myun 
+{
+    struct { int x; int y; int z; }u; 
+    int k; 
+}a; 
+int main() 
+{ 
+    a.u.x =4;
+    a.u.y =5; 
+    a.u.z =6; 
+    a.k = 0; //覆盖掉第一个int空间值
+    printf("%d %d %d %d\n",a.u.x,a.u.y,a.u.z,a.k);
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day10/readme.md

@@ -0,0 +1 @@
+# 文件与流

practical_exercises/10_day_practice/day10/文件例题/12-1.cpp

@@ -0,0 +1,18 @@
+//用cin输入字符串数据时，如果字符串中含有空白就不能完整输入。因为遇到空白字符时，cin就认为字符串结束了。
+#include<iostream>
+using namespace std;
+int main(int argc, char const *argv[])
+{
+    char a[50];
+    cout<<"please input a string:";
+    cin>>a;
+    cout<<a<<endl;
+    system("pause");
+    return 0;
+}
+/*
+若a的内容是：
+this is a string! 
+就难以输入啦！
+这样的数据应用输入流类的成员函数输入
+*/

practical_exercises/10_day_practice/day10/文件例题/12-2应用.cpp

@@ -0,0 +1,13 @@
+#include<iostream>
+using namespace std;
+int main(int argc, char const *argv[])
+{
+    char stu[5][10];
+    int i;
+    for(i=0;i<5;i++)
+        cin.getline(stu[i],10,',');
+    for(i=0;i<5;i++)
+        cout<<stu[i]<<endl;
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day10/文件例题/12-3.cpp

@@ -0,0 +1,18 @@
+#include<iostream>
+using namespace std;
+//º¯ÊýÔ­ÐÍ
+//put(char c)
+//write(const char*c, int n)
+int main(){
+    char c;
+    char a[50]="this is a string...";
+    cout<<"use get() input char:";
+    while((c=cin.get())!='\n'){
+        cout.put(c);
+        cout.put('\n');
+        cout.put('t').put('h').put('i').put('s').put('\n');
+        cout.write(a,12).put('\n');
+        cout<<"look"<<"\t here!"<<endl;
+    }
+    system("pause");
+}

practical_exercises/10_day_practice/day10/文件例题/12-5.cpp

@@ -0,0 +1,17 @@
+//Eg12-5.cpp
+#include<iostream>
+#include<iomanip>
+using namespace std;
+int main(){
+    char c[30]="this is string";
+    double d=-1234.8976;
+    cout<<setw(30)<<left<<setfill('*')<<c<<"----L1"<<endl;
+    cout<<setw(30)<<right<<setfill('*')<<c<<"----L2"<<endl;
+    //showbase显示数值的基数前缀
+    cout<<dec<<showbase<<showpoint<<setw(30)<<d<<"----L3"<<"\n";
+    //showpoint显示小数点
+    cout<<setw(30)<<showpoint<<setprecision(10)<<d<<"----L4"<<"\n";
+    //setbase(8)设置八进制
+    cout<<setw(30)<<setbase(16)<<100<<"----L5"<<"\n";
+    system("pause");
+}

practical_exercises/10_day_practice/day10/文件例题/12-6.cpp

@@ -0,0 +1,28 @@
+//12-6.cpp
+#include<iostream>
+#include<fstream>
+using namespace std;
+int main(int argc, char const *argv[])
+{
+    fstream ioFile;
+    ioFile.open("./a.dat",ios::out);
+    ioFile<<"张三"<<"  "<<76<<" "<<98<<" "<<67<<endl;	//L3
+    ioFile<<"李四"<<"  "<<89<<" "<<70<<" "<<60<<endl;
+    ioFile<<"王十"<<"  "<<91<<" "<<88<<" "<<77<<endl;
+    ioFile<<"黄二"<<"  "<<62<<" "<<81<<" "<<75<<endl;
+    ioFile<<"刘六"<<"  "<<90<<" "<<78<<" "<<67<<endl;
+    ioFile.close();
+    ioFile.open("./a.dat",ios::in|ios::binary);
+    char name[10];
+    int chinese,math,computer;
+    cout<<"姓名\t"<<"英语\t"<<"数学\t"<<"计算机\t"<<"总分"<<endl; 
+    ioFile>>name;										
+    while(!ioFile.eof())	{								
+        ioFile>>chinese>>math>>computer;					
+        cout<<name<<"\t"<<chinese<<"\t"<<math<<"\t"<<computer<<"\t"<<chinese+math+computer<<endl;		
+        ioFile>>name;
+    }
+    ioFile.close();										
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day10/文件例题/12-7.cpp

@@ -0,0 +1,21 @@
+//Eg12-7.cpp
+#include <iostream>
+#include <fstream>
+using namespace std;
+int main(){
+    char ch;
+    ofstream out("/test.dat",ios::out|ios::binary);		//L1
+    for(int i=0;i<90;i++){
+        if(i>0 && (i % 30)==0)
+		    out.put('\n');						
+        out.put(i);							
+        out.put(' ');	
+        						
+	}
+    out.close();							    
+    ifstream in("/test.dat",ios::in|ios::binary);
+    while(in.get(ch))
+		cout<<ch;				
+	in.close();		
+    system("pause");					
+}

practical_exercises/10_day_practice/day10/文件例题/12-9.cpp

@@ -0,0 +1,41 @@
+//Eg12-12.cpp
+#include <iostream>
+#include <cstring>
+#include <fstream>
+using namespace std;
+class Employee{
+private:
+    int number ,age;
+    char name[20];
+    double sal;
+public:
+    Employee(){}
+    Employee(int num,char* Name,int Age, double Salary){
+        number=num;
+        strcpy(name,Name);
+        age=Age;
+        sal=Salary;
+    }
+    void display(){
+        cout<<number<<"\t"<<name<<"\t"<<age<<"\t"<<sal<<endl;
+    }
+};
+
+int main(){
+    ofstream out("D:/Employee.dat",ios::out);	//定义随机输出文件
+    Employee e1(1,"张三",23,2320);
+    Employee e2(2,"李四",32,3210);
+    Employee e3(3,"王五",34,2220);
+    Employee e4(4,"刘六",27,1220);
+    out.write((char*)&e1,sizeof(e1));		//按e1,e2,e3,e4顺序写入文件
+    out.write((char*)&e2,sizeof(e2));
+    out.write((char*)&e3,sizeof(e3));
+    out.write((char*)&e4,sizeof(e4));
+
+     //下面的代码将e3（即王五）的年龄改为40岁   
+    Employee e5(3,"王五",40,2220);
+    out.seekp(3*sizeof(e1));		//指针定位到第3（起始为0）个数据块
+    out.write((char*)&e5,sizeof(e5));	//将e5写到第3个数据块位置，覆盖e3
+    out.close();			//关闭文件
+    system("pause");
+}

practical_exercises/10_day_practice/day10/文件例题/三种输入格式/get()12-2.cpp

@@ -0,0 +1,21 @@
+//【例12-2】  用函数get和getline读取数据。
+#include <iostream>
+using namespace std;
+int main()
+{
+	char a,b,c,d;
+	cin.get(a);
+	cin.get(b);
+	c = cin.get();
+	d = cin.get();
+	cout<<int(a)<<','<<int(b)<<','<<int(c)<<','<<int(d)<<endl;
+    system("pause");
+    return 0;
+}
+
+/*
+用法：a = cin.get() ?或者 ?cin.get(a)
+结束条件：输入字符足够后回车
+说明：这个是单字符的输入，用途是输入一个字符，把它的ASCALL码存入到a中
+处理方法：与cin不同，cin.get()在缓冲区遇到[enter]，[space]，[tab]不会作为舍弃，而是继续留在缓冲区中
+*/

practical_exercises/10_day_practice/day10/文件例题/三种输入格式/get(a,size)12-2-1.cpp

@@ -0,0 +1,44 @@
+
+//【例12-2】  用函数get和getline读取数据。
+#include <iostream>
+using namespace std;
+//cin.get(arrayname,size)  把字符输入到arrayname中，长度不超过size
+int main()
+{
+    //get()两个参数
+
+    //1.输入串长<size，输入串长>arraylength，会自动扩张arrayname大小，使能保存所有数据
+	// char a[10];
+	// cin.get(a,20);
+	// cout<<a<<endl;
+    // cout<<sizeof(a)<<endl;
+    //2.输入串长<size，输入串长<arraylength，把串全部输入，后面补‘\0’
+    // char b[10];
+	// cin.get(b,20);
+	// cout<<b<<endl;//12345，此时数组内数据为‘12345'\0’
+    // cout<<sizeof(b)<<endl;
+    //3.输入串长>size，先截取size个字符，若还是大于arraylength，则输入前arraylength-1个字符，最后补充‘\0’
+    // char c[5];
+	// cin.get(c,10);
+	// cout<<c<<endl;
+    // cout<<sizeof(c)<<endl;
+    //4.输入串长>size，先截取size个字符，若小于arraylength，则把截取串放入数组中，最后补充‘\0’
+    // char d[10];
+	// cin.get(d,5);
+	// cout<<d<<endl;
+    // cout<<sizeof(d)<<endl;
+    
+    //get()三个参数
+    /*
+        用法：cin.get(arrayname,size,s) ?把数据输入到arrayname字符数组中，当到达长度size时结束或者遇到字符s时结束
+        注释：a必须是字符数组，即char a[]l类型，不可为string类型；size为最大的输入长度；s为控制，遇到s则当前输入结束缓存区里的s将被舍弃
+
+    */
+    int i;
+    char e[10];
+    cin.get(e,8,',');
+    cout<<e;
+    system("pause");
+    return 0;
+}
+

practical_exercises/10_day_practice/day10/文件例题/三种输入格式/getline()12-2-2.cpp

@@ -0,0 +1,38 @@
+#include<iostream>
+using namespace std;
+/*
+（1）cin.getline(arrayname,size)与cin.get(arrayname,size)的区别
+cin.get(arrayname,size)当遇到[enter]时会结束目前输入，他不会删除缓冲区中的[enter]
+cin.getline(arrayname,size)当遇到[enter]时会结束当前输入，但是会删除缓冲区中的[enter]
+*/
+int main()
+{
+    /*
+	char a[10];
+    char b;
+    cin.get(a,10);
+	cin.get(b);
+    cout<<a<<endl<<int(b);//输入：12345[enter] 输出：12345 【换行】 10*/
+    /*char c[10];
+    char d;
+    cin.getline(c,10);
+    cin.get(d);
+	cout<<c<<endl<<int(d);//输入：12345[enter]a[enter] 输出：12345【换行】97*/
+    //cin.getline(arrayname,size,s)与cin.gei(arrayname,size,s)的区别
+    /*
+    cin.getline(arrayname,size,s)当遇到s时会结束输入，并把s从缓冲区中删除
+    cin.get（arrayname,size,s）当遇到s时会结束输入，但不会删除缓冲区中的s
+    */
+   /*
+    char e[10];
+    char f;
+    cin.get(e,10,',');
+	cin.get(f);
+	cout<<e<<endl<<f;//输入：12345,[enter] 输出：12345【换行】，说明：cin,get不会删除缓冲区的，*/
+    char e1[10];
+    char f1;
+    cin.getline(e1,10,',');
+	cin.get(f1);
+	cout<<e1<<endl<<f1;//输入：asd,wqe 输出：asd【换行】w
+    system("pause");
+}

practical_exercises/10_day_practice/day10/文件例题/输出格式10-4.cpp

@@ -0,0 +1,28 @@
+#include<iostream>
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+    char c[30]="this is string";
+    double d = -1231.232;
+    cout.width(30);
+    cout.fill('*');
+    cout.setf(ios::left);
+    cout<<c<<"----L1"<<endl;
+    cout.width(30);
+    cout.fill('-');
+    cout.setf(ios::right);
+    cout<<c<<"----L2"<<endl;
+    cout.setf(ios::dec|ios::showbase|ios::showpoint);
+    cout.width(30);
+    cout<<d<<"----L3"<<"\n";
+    cout.setf(ios::showpoint);
+    cout.precision(10);
+    cout.width(30);
+    cout<<d<<"----L4"<<"\n";
+    cout.width(30);
+    cout.setf(ios::oct,ios::basefield);
+    cout<<100<<"----L5"<<"\n";
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day10/文件例题/重要!!!课堂练习.cpp

@@ -0,0 +1,63 @@
+#include<iostream>
+#include<fstream>
+//向量是一个能够存放任意类型的动态数组
+#include<vector>
+#include<cstring>
+using namespace std;
+class Person{
+    private:
+        char name[20];
+        char id[18];
+        int age;
+        char addr[20];
+    public:
+        Person(){}
+        Person(char *n,char *pid,int Age,char* Addr){
+            strcpy(name,n);
+            strcpy(id,pid);
+            age=Age;
+            strcpy(addr,Addr);
+        }
+        void display(){
+            cout<<name<<"\t"<<id<<"\t"<<age<<"\t"<<addr<<endl;
+        }
+};
+int main(int argc, char const *argv[])
+{
+    vector<Person> v;
+    vector<Person>::iterator pos;//声明一个迭代器，来访问vector容器，作用：遍历或者指向vector容器的元素 
+    char ch;
+    ofstream out("d:/person.dat",ios::out|ios::app|ios::binary);
+    char Name[20],ID[18],Addr[20];
+    int Age;
+    cout<<"------输入个人档案------"<<endl<<endl;
+    do{
+        cout<<"姓名： ";
+        cin>>Name;
+        cout<<"身份证号： ";
+        cin>>ID;
+        cout<<"年龄： ";
+        cin>>Age;
+        cout<<"地址： ";
+        cin>>Addr;
+        Person per(Name,ID,Age,Addr);
+        out.write((char*)&per,sizeof(per));
+        cout<<"Enter another Person(y/n)?";
+        cin>>ch;
+    }while(ch=='y');
+    out.close();
+    ifstream in("d:/person.dat",ios::in|ios::binary);	//L9
+    Person s;
+    in.read((char*)&s,sizeof(s));		
+    while(!in.eof()){							       
+        v.push_back(s);						       
+        in.read((char*)&s,sizeof(s));			
+    }								 
+    cout<<"\n---------从文件中读出的数据--------"<<endl<<endl;//L15
+    pos=v.begin();						
+    for(pos=v.begin();pos!=v.end();pos++)				        
+        (*pos).display();				
+
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day2/x的n次方.cpp

@@ -0,0 +1,32 @@
+#include<iostream>
+using namespace std;
+double power(double x, int n);
+
+int main(int argc, char const *argv[])
+{
+    int x;
+    cin>>x;
+    int wei=0;
+    int sum=0;
+    int each,chu;
+    for(int i=0;i<8;i++)
+    {
+        each=x%10;
+        chu=x/10;
+        sum+=each*power(2,wei);
+        x=chu;
+        wei++;
+    }
+    cout<<sum<<endl;
+    system("pause");
+    return 0;
+}
+double power(double x, int n)
+{
+    double val = 1.0;
+    while(n--)
+    {
+        val*=x;
+    }
+    return val;
+}

practical_exercises/10_day_practice/day2/掷骰子.cpp

@@ -0,0 +1,63 @@
+#include<iostream>
+#include<cstdlib>
+using namespace std;
+int rolldice();
+int main(int argc, char const *argv[])
+{
+    int flag;
+    unsigned seed;
+    cout<<"ÇëÊäÈëÎÞ·ûºÅÕûÊý£º"<<endl;
+    cin>>seed;
+    srand(seed);
+    int sum = rolldice();
+    int selfdim;
+    switch(sum)
+    {
+        case 7:
+        case 11:
+            flag=1;
+            break;
+        case 2:
+        case 3:
+        case 12:
+            flag=2;
+            break;
+        default:
+            flag=0;
+            selfdim=sum;
+            break;
+    }
+    while(flag==0)
+    {
+        sum=rolldice();
+        if(sum==selfdim)
+        {
+            flag=1;
+        }
+        else if(sum==7)
+        {
+            flag=2;
+        }
+    }
+    if(flag==1)
+    {
+        cout<<"player win\n";
+    }
+    else
+    {
+        cout<<"player loses\n";
+    }
+
+    system("pause");
+    return 0;
+}
+
+int rolldice()
+{   
+    int sum=0;
+    int dim1 = rand()%6+1;
+    int dim2 = rand()%6+1;
+    sum = dim1+dim2;
+    cout<<"sum="<<dim1<<"+"<<dim2<<endl;
+    return sum;
+}

practical_exercises/10_day_practice/day2/枚举类型.cpp

@@ -0,0 +1,21 @@
+#include<iostream>
+using namespace std;
+
+enum weekday
+{
+ s,m,t,w,thu,f,s1
+};
+
+int main(int argc, char const *argv[])
+{
+    enum weekday wek=s;
+    // weekday wek=s;
+    for(int i=wek;i!=f;i++)
+    {
+        cout<<i<<endl;
+        cout<<wek+s<<endl;
+        cout<<"-------¹þ¹þ-------"<<endl;
+    }
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day2/求π.cpp

@@ -0,0 +1,28 @@
+#include<iostream>
+using namespace std;
+double arctan(double x);
+int main(int argc, char const *argv[])
+{
+    double a = 16.0*arctan(1.0/5.0);
+    double b = 4.0*arctan(1.0/239.0);
+    double pi = a-b;
+    cout<<pi<<endl;
+    system("pause");
+    return 0;
+}
+double arctan(double x)
+{
+    double head=x;
+    int tail=1;
+    double art=0;
+    while(double(head/tail)>1e-15)
+    {
+        art=(tail%4==1)? art+head/tail: art-head/tail;
+        head*=x*x;
+        tail+=2;
+        cout<<"---------------"<<endl;
+        cout<<tail<<endl;
+        cout<<"---------------"<<endl;
+    }
+    return art;
+}

practical_exercises/10_day_practice/day2/汉诺塔.cpp

@@ -0,0 +1,33 @@
+#include<iostream>
+using namespace std;
+void move(char A, char B);
+void hanoi(int n,char A, char B, char C);
+int main(int argc, char const *argv[])
+{
+    cout<<"ÇëÊäÈëÅÌ×ÓÊýÁ¿£º";
+    int disks;
+    cin>>disks;
+    hanoi(disks,'A','B','C');
+    system("pause");
+    return 0;
+}
+
+
+void move(char A, char B)
+{
+    cout<<A<<"->"<<B<<endl;
+}
+
+void hanoi(int n, char A, char B, char C)
+{
+    if (n==1)
+    {
+        move(A,C);
+    }
+    else
+    {
+        hanoi(n-1,A,C,B);
+        move(A,C);
+        hanoi(n-1,B,A,C);
+    }
+}

practical_exercises/10_day_practice/day2/结构体.cpp

@@ -0,0 +1,21 @@
+#include<iostream>
+using namespace std;
+struct student
+{
+    int num;
+    char name[20];
+    char gender;
+};
+
+int main(int argc, char const *argv[])
+{
+    student s={10,"asd",'M'};
+    cout<<s.num<<endl;
+    cout<<sizeof(s.num)<<endl;
+    cout<<sizeof(s.name)<<endl;
+    cout<<sizeof(s.gender)<<endl;
+    cout<<sizeof(s)<<endl;
+    system("pause");
+    return 0;
+}
+

practical_exercises/10_day_practice/day2/递归1.cpp

@@ -0,0 +1,25 @@
+#include<iostream>
+using namespace std;
+
+int f(int n);
+int main(int argc, char const *argv[])
+{   
+    cout<<"input x:";
+    int x;
+    cin>>x;
+    cout<<f(x)<<endl;
+    system("pause");
+    return 0;
+}
+
+int f(int n)
+{
+    if(n==0)
+    {
+        return 1;
+    }
+    else
+    {
+        return n*f(n-1);
+    }
+}

practical_exercises/10_day_practice/day2/递归2.cpp

@@ -0,0 +1,25 @@
+#include<iostream>
+using namespace std;
+int f(int n, int k);
+int main(int argc, char const *argv[])
+{
+    cout<<"ÇëÊäÈënÓëk"<<endl;
+    int n,k;
+    cin>>n;
+    cin>>k;
+    cout<<f(n,k)<<endl;
+    system("pause");
+    return 0;
+}
+
+int f(int n, int k)
+{
+    if ((n==k)||(k==0))
+    {
+        return 1;
+    }
+    else
+    {
+        return f(n-1,k-1)+f(n-1,k);
+    }
+}

practical_exercises/10_day_practice/day2/静态变量.cpp

@@ -0,0 +1,32 @@
+#include<iostream>
+using namespace std;
+int i=1;  // i 为全局变量，具有静态生存期。
+int main(void)   
+{ 
+    static int a;  // 静态局部变量，有全局寿命，局部可见。
+    int b=-10;  // b, c为局部变量，具有动态生存期。
+    int c=0;
+    void other(void);
+    cout<<"---MAIN---\n";
+    cout<<" i: "<<i<<" a: "<<a<<" b: "<<b<<" c: "<<c<<endl;//1 0 -10 0
+    c=c+8;  other();// 33 4 0 15
+    cout<<"---MAIN---\n";
+    cout<<" i: "<<i<<" a: "<<a<<" b: "<<b<<" c: "<<c<<endl;//33 0 -10 8 
+    i=i+10; other();  //75 6 4 15
+    other(); //107 8 6 15
+    system("pause");
+    return 0;
+}
+void other(void)
+{
+    static int a=2;
+    static int b;
+    // a,b为静态局部变量，具有全局寿命，局部可见。
+    //只第一次进入函数时被初始化。
+    int c=10;   // C为局部变量，具有动态生存期
+    //每次进入函数时都初始化。
+    a=a+2; i=i+32; c=c+5;
+    cout<<"---OTHER---\n";
+    cout<<" i: "<<i<<" a: "<<a<<" b: "<<b<<" c: "<<c<<endl;
+    b=a;
+}

practical_exercises/10_day_practice/day3/两数交换.cpp

@@ -0,0 +1,21 @@
+#include<iostream>
+using namespace std;
+void swap(int & a, int & b);
+int main(int argc, char const *argv[])
+{
+    int x1(5);
+    int x2(7);
+    swap(x1,x2);
+    cout<<x1<<" "<<x2<<endl;
+    system("pause");
+    return 0;
+}
+
+void swap(int & a, int & b)
+{
+    int t;
+    t = a;
+    a = b;
+    b = t;
+
+}

practical_exercises/10_day_practice/day3/内联函数.cpp

@@ -0,0 +1,18 @@
+#include<iostream>
+using namespace std;
+//函数声明
+inline double CalArea(double radius);
+int main(int argc, char const *argv[])
+{
+    double r(3.0);
+    double area;
+    area = CalArea(r);
+    cout<<area<<endl;
+    system("pause");
+    return 0;
+}
+//加关键字inline
+inline double CalArea(double radius)
+{
+    return 3.14*radius*radius;
+}

practical_exercises/10_day_practice/day3/函数综合练习题.cpp

@@ -0,0 +1,61 @@
+/*
+一圆型游泳池如图所示，现在需在其周围建一圆型过道，并在其四周围上栅栏。栅栏价格为35元/米，过道造价为20元/平方米。
+过道宽度为3米，游泳池半径由键盘输入。要求编程计算并输出过道和栅栏的造价。
+
+图形描述：大圆嵌套小圆：
+小圆在大圆中间，小圆为游泳池，大圆与小圆间隔为过道。
+*/
+#include<iostream>
+using namespace std;
+const float PI=3.14159;
+const float FencePrice=35;
+const float ConcretePrice=20;
+
+class Circle
+{
+    private:
+        float radius;
+    public:
+        Circle(float r);
+        float Circumference() const;
+        float Area() const;
+};
+Circle::Circle(float r)
+{
+    radius=r;
+}
+
+// 计算圆的周长
+float Circle::Circumference() const
+{
+    return 2 * PI * radius;
+}
+        
+// 计算圆的面积 
+float Circle::Area() const
+{
+    return PI * radius * radius;
+}
+
+int main(int argc, char const *argv[])
+{
+    float radius;
+    float FenceCost, ConcreteCost; 
+    
+    // 提示用户输入半径
+    cout<<"Enter the radius of the pool: ";
+    cin>>radius;
+
+    // 声明 Circle 对象
+    Circle Pool(radius);
+    Circle PoolRim(radius + 3);       
+    // 计算栅栏造价并输出
+    FenceCost = PoolRim.Circumference() * FencePrice;
+    cout << "Fencing Cost is ￥" << FenceCost << endl;
+    
+    //  计算过道造价并输出
+    ConcreteCost = (PoolRim.Area() - Pool.Area())*ConcretePrice;
+    cout << "Concrete Cost is ￥" << ConcreteCost << endl;
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day3/类前向声明.cpp

@@ -0,0 +1,40 @@
+/*
+使用前向引用声明虽然可以解决一些问题，但它并不是万能的。需要注意的是，
+尽管使用了前向引用声明，但是在提供一个完整的类声明之前，不能声明该类的对象，
+也不能在内联成员函数中使用该类的对象。请看下面的程序段：
+*/
+
+//第一种
+#include<iostream>
+class Fred;	//前向引用声明
+class Barney {
+   Fred x;	//错误：类Fred的声明尚不完善
+};
+class Fred {
+   Barney y;
+};
+
+
+//第二种
+class Fred;	//前向引用声明
+ 
+class Barney {
+ public:
+   void method()
+   {
+     x->yabbaDabbaDo();	//错误：Fred类的对象在定义之前被使用
+   }
+ private:
+   Fred* x;   //正确，经过前向引用声明，可以声明Fred类的对象指针
+ };
+ 
+class Fred {
+ public:
+   void yabbaDabbaDo();
+ private:
+   Barney* y;
+}; 
+
+/*
+总结：当使用前向引用声明时，只能使用被声明的符号，而不能涉及类的任何细节。
+*/

practical_exercises/10_day_practice/day3/静态成员函数1.cpp

@@ -0,0 +1,30 @@
+/*
+知识点：
+静态成员函数
+类外代码可以使用类名和作用域操作符来调用静态成员函数。
+静态成员函数只能引用属于该类的静态数据成员或静态成员函数。
+*/
+#include<iostream>
+using namespace std;
+class Application
+{ 
+public:
+    static void f(); 
+    static void g();
+private:
+    static int global;
+};
+int Application::global=0;
+void Application::f()
+{  global=5;}
+void Application::g()
+{  cout<<global<<endl;}
+
+int main()
+{
+    Application::f();
+    Application::g();
+    system("pause");
+    return 0;
+}
+

practical_exercises/10_day_practice/day3/静态成员函数2.cpp

@@ -0,0 +1,24 @@
+#include<iostream>
+using namespace std;
+class A
+{
+    public:
+        static void f(A a);
+    private:
+        int x;
+};
+void A::f(A a)
+{
+   
+    //静态成员函数只能引用属于该类的静态数据成员或静态成员函数。
+    // cout<<x; //对x的引用是错误的
+    cout<<a.x;  //正确
+}
+
+int main(int argc, char const *argv[])
+{
+    A a;
+    a.f(A());
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day3/静态数据成员.cpp

@@ -0,0 +1,39 @@
+/*
+学习知识：
+静态数据成员
+用关键字static声明
+该类的所有对象维护该成员的同一个拷贝
+必须在类外定义和初始化，用(::)来指明所属的类。
+*/
+#include <iostream>
+using namespace std;
+class Point	
+{
+public:	
+	Point(int xx=0, int yy=0) {X=xx; Y=yy; countP++; } 
+    Point(Point &p);	
+	int GetX() {return X;}
+	int GetY() {return Y;}
+	void GetC() {cout<<" Object id="<<countP<<endl;}
+private:	
+	int X,Y;
+    //静态数据成员，必须在外部定义和初始化，内部不能直接初始化！
+	static int countP;
+};
+Point::Point(Point &p)
+{	X=p.X;
+	Y=p.Y;
+	countP++;
+}
+//必须在类外定义和初始化，用(::)来指明所属的类。
+int Point::countP=0; 
+int main()	
+{	Point A(4,5);	
+	cout<<"Point A,"<<A.GetX()<<","<<A.GetY();
+	A.GetC();	
+	Point B(A);	
+	cout<<"Point B,"<<B.GetX()<<","<<B.GetY();
+	B.GetC();	
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day4/const用法/readme.md

@@ -0,0 +1,8 @@
+常类型的对象必须进行初始化，而且不能被更新。
+常引用：被引用的对象不能被更新。
+const  类型说明符  &引用名
+常对象：必须进行初始化,不能被更新。
+类名  const  对象名
+常数组：数组元素不能被更新。
+类型说明符  const  数组名[大小]...
+常指针：指向常量的指针。

practical_exercises/10_day_practice/day4/const用法/常对象与常引用.cpp

@@ -0,0 +1,24 @@
+
+#include<iostream>
+using namespace std;
+void display(const double& r);
+
+class A
+{
+     public:
+         A(int i,int j) {x=i; y=j;}
+     private:
+         int x,y;
+};
+int main()
+{   double d(9.5);
+     display(d);
+     A const a(3,4); //a是常对象，不能被更新
+     system("pause");
+     return 0;
+}
+void display(const double& r)
+//常引用做形参，在函数中不能更新 r所引用的对象。
+{   cout<<r<<endl;   }
+
+

practical_exercises/10_day_practice/day4/const用法/常对象与普通函数.cpp

@@ -0,0 +1,41 @@
+#include<iostream>
+using namespace std;
+class R
+{    public:
+         R(int r1, int r2){R1=r1;R2=r2;}
+         //const区分成员重载函数
+         void print();
+         void print() const;
+      private:
+         int R1,R2;
+};
+/*
+常成员函数说明格式：类型说明符  函数名（参数表）const;
+这里，const是函数类型的一个组成部分，因此在实现部分也要带const关键字。
+const关键字可以被用于参与对重载函数的区分
+通过常对象只能调用它的常成员函数
+*/
+
+void R::print()
+{     
+    cout<<"普通调用"<<endl;
+    cout<<R1<<":"<<R2<<endl;
+}
+//实例化也需要带上
+void R::print() const
+{     
+    cout<<"常对象调用"<<endl;
+    cout<<R1<<";"<<R2<<endl;
+}
+int main()
+{   
+    R a(5,4);
+    a.print();  //调用void print()
+    //通过常对象只能调用它的常成员函数
+    const R b(20,52);  
+    b.print();  //调用void print() const
+    system("pause");
+    return 0;
+}
+
+

practical_exercises/10_day_practice/day4/友元函数/readme.md

@@ -0,0 +1,9 @@
+# 友元概念？
+友元是C++提供的一种破坏数据封装和数据隐藏的机制。
+通过将一个模块声明为另一个模块的友元，一个模块能够引用到另一个模块中本是被隐藏的信息。
+可以使用友元函数和友元类。
+为了确保数据的完整性，及数据封装与隐藏的原则，建议尽量不使用或少使用友元。
+# 如何使用？
+友元函数是在类声明中由关键字friend修饰说明的非成员函数，在它的函数体中能够通过对象名访问 private 和 protected成员
+作用：增加灵活性，使程序员可以在封装和快速性方面做合理选择。
+访问对象中的成员必须通过对象名。

practical_exercises/10_day_practice/day4/友元函数/友元模块.cpp

@@ -0,0 +1,31 @@
+//使用友元函数计算两点间距离
+#include <iostream>
+#include <cmath>
+using namespace std;
+class Point{
+  public:
+    Point(int x=0,int y=0):X(x),Y(y){}
+    int GetX(){
+      return X;
+    }
+    int GetY(){
+      return Y;
+    }
+    friend float Distance(Point &a,Point &b);
+  private:
+    int X,Y;//私有数据成员
+};
+//通过将一个模块声明为另一个模块的友元，一个模块能够引用到另一个模块中本是被隐藏的信息。
+float Distance(Point &a, Point &b){
+  double dx = a.X-b.X;
+  double dy = a.Y-b.Y;
+  return sqrt(dx*dx+dy*dy);
+}
+
+int main()
+{  
+    Point p1(3.0,5.0),p2(4.0,6.0);
+    cout<<"两点距离为："<<Distance(p1,p2)<<endl;
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day4/友元函数/友元类.cpp

@@ -0,0 +1,49 @@
+#include<iostream>
+using namespace std;
+/*
+若一个类为另一个类的友元，则此类的所有成员都能访问对方类的私有成员。
+声明语法：将友元类名在另一个类中使用friend修饰说明。
+*/
+
+/*
+如果声明B类是A类的友元，B类的成员函数就可以访问A类的私有和保护数据，
+但A类的成员函数却不能访问B类的私有、保护数据。
+*/
+class A{
+  friend class B;
+  public:
+    void Display(){
+      cout<<x<<endl;
+    }
+    private:
+      int x;
+};
+class B
+{   public:
+      void Set(int i);
+      void Display();
+    private:
+      A a;
+};
+void B::Set(int i)
+{
+   a.x=i;
+}
+void B::Display()
+{
+   a.Display();
+}
+
+int main(int argc, char const *argv[])
+{
+    B b;
+    b.Set(10);
+    b.Display();
+
+    system("pause");
+    return 0;
+}
+
+/*
+如果声明B类是A类的友元，B类的成员函数就可以访问A类的私有和保护数据，但A类的成员函数却不能访问B类的私有、保护数据
+*/

practical_exercises/10_day_practice/day4/拷贝构造函数/clock.cpp

@@ -0,0 +1,47 @@
+#include<iostream>
+#include"clock.h"
+using namespace std;
+Clock::Clock(int NewH,int NewM,int NewS)
+{
+    this->Hour=NewH;
+    this->Minute=NewM;
+    this->Second=NewS;
+}
+Clock::Clock(Clock &c)
+{
+    this->Hour=c.Hour;
+    this->Minute=c.Minute;
+    this->Second=c.Second;
+}
+void Clock::SetTime(int NewH,int NewM,int NewS)
+{
+    //加不加this指针都一样
+    this->Hour=NewH;
+    this->Minute=NewM;
+    this->Second=NewS;
+}
+void Clock::ShowTime()
+{
+    cout<<this->Hour<<endl;
+    cout<<this->Minute<<endl;
+    cout<<this->Second<<endl;
+}
+//析构函数
+Clock::~Clock()
+{
+
+}
+int main(int argc, char const *argv[])
+{
+    Clock c(0,0,0);
+    
+    c.SetTime(10,20,30);
+    c.ShowTime();
+    //拷贝构造函数调用
+    Clock c1(c);
+    c1.ShowTime();
+    c1.SetTime(90,98,99);
+    c1.ShowTime();
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day4/拷贝构造函数/clock.h

@@ -0,0 +1,26 @@
+#ifndef CLOCK
+# define CLOCK
+class Clock
+{
+    public:
+        Clock(int NewH,int NewM,int NewS);
+        Clock(Clock &c);//拷贝构造函数,如果不加，编译器会自动生成一个拷贝构造函数，因此加不加都可以直接使用。
+        void SetTime(int NewH,int NewM,int NewS);
+        void ShowTime();
+        ~Clock();//析构函数，编译器会自动产生一个默认的析构函数。
+    private:
+        int Hour,Minute,Second;
+};
+
+#endif
+
+
+/*
+#ifndef   标识符
+       程序段1
+#else
+       程序段2
+#endif
+如果“标识符”未被定义过，则编译程序段1，否则编译程序段2。
+
+*/

practical_exercises/10_day_practice/day4/时钟练习题/重载()的时钟.cpp

@@ -0,0 +1,25 @@
+#include <iostream>
+using namespace std;
+class Time{
+private:
+    int hh,mm,ss;
+public:
+    Time(int h=0,int m=0,int s=0):hh(h),mm(m),ss(s){}
+    void operator()(int h,int m,int s) {
+        hh=h;
+        mm=m;
+        ss=s;
+    }
+    void ShowTime(){
+        cout<<hh<<":"<<mm<<":"<<ss<<endl;
+    }
+};
+int main(){
+    Time t1(12,10,11);
+    t1.ShowTime();
+    t1.operator()(23,20,34);	
+    t1.ShowTime();
+    t1(10,10,10);               	
+    t1.ShowTime();
+    system("pause");
+}

practical_exercises/10_day_practice/day4/时钟练习题/重载++的时钟.cpp

@@ -0,0 +1,45 @@
+/*
+设计一个时钟类，能够记录时、分、秒，重载它的++运算符，每执行一次++运算，加时1秒，但要使计时过程能够自动进位。
+*/
+#include<iostream>
+using namespace std;
+class Time{
+    public:
+        Time(int h=0,int m=0,int s=0){
+            hour = h;
+            minute = m;
+            second = s;
+        }
+        void operator++();
+        void showTime(){
+            cout<<"当前时间为："<<hour<<":"<<minute<<":"<<second<<endl;
+        }
+
+    private:
+        int hour,minute,second;
+
+};
+
+void Time::operator++(){
+    ++second;
+    if(second=60){
+        second=0;
+        ++minute;
+        if(minute==60){
+            minute=0;
+            hour++;
+            if(hour==24){
+                hour=0;
+            }
+        }
+    }
+}
+
+int main(int argc, char const *argv[])
+{
+    Time t(23,59,59);
+    ++t;
+    t.showTime();
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day5/基类与派生类关系/readme.md

@@ -0,0 +1,8 @@
+1.基类与派生类对象的关系 
+
+基类对象与派生类对象之间存在赋值相容性。包括以下几种情况：
+把派生类对象赋值给基类对象。
+把派生类对象的地址赋值给基类指针。
+用派生类对象初始化基类对象的引用。
+反之则不行，即不能把基类对象赋值给派生类对象；不能把基类对象的地址赋值给派生类对象的指针；也不能把基类对象作为派生对象的引用。
+

practical_exercises/10_day_practice/day5/基类与派生类关系/基类与派生类(重要).cpp

@@ -0,0 +1,55 @@
+#include <iostream>
+using namespace std;
+class A {
+    int a;
+public: 
+    void setA(int x){ a=x; }
+    int getA(){ return a;} 
+}; 
+class B:public A{
+    int b;
+public: 
+    void setB(int x){ b=x; }
+    int getB(){ return b;} 
+};
+void f1(A a, int x)
+{ a.setA(x); }      
+void f2(A *pA, int x)
+{ pA->setA(x); }
+void f3(A &rA, int x)
+{ rA.setA(x); }
+
+int main(){
+    A a1,*pA;
+    B b1,*pB;
+    a1.setA(1);
+    b1.setA(2);
+    //把派生类对象赋值给基类对象。
+    a1=b1;                  
+    cout<<a1.getA()<<endl;		
+    cout<<b1.getA()<<endl; 		
+    a1.setA(10);              
+    cout<<a1.getA()<<endl;		
+    cout<<b1.getA()<<endl;	
+    //把派生类对象的地址赋值给基类指针。	 	
+    pA=&b1;  
+    pA->setA(20);            
+    cout<<pA->getA()<<endl;	    
+    cout<<b1.getA()<<endl;	
+    //用派生类对象初始化基类对象的引用。
+    A &ra=b1;                                    
+    ra.setA(30);               
+    cout<<pA->getA()<<endl;		
+    cout<<b1.getA()<<endl;		    
+    b1.setA(7);
+    cout<<b1.getA()<<endl;		    
+    f1(b1,100); 
+    cout<<"1111111111"<<endl;
+    cout<<b1.getA()<<endl;	//7	    
+    f2(&b1,200);
+    cout<<b1.getA()<<endl;		    
+    f3(b1,300);
+    cout<<b1.getA()<<endl;		
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day5/构造函数与析构函数/readme.md

@@ -0,0 +1,22 @@
+一、类对象成员的构造
+先构造成员
+再构造自身（调用构造函数）
+二、派生类构造函数
+派生类可能有多个基类，也可能包括多个成员对象，在创建派生类对象时，派生类的构造函数除了要负责本类成员的初始化外，还要调用基类和成员对象的构造函数，并向它们传递参数，以完成基类子对象和成员对象的建立和初始化。
+
+**派生类只能采用构造函数初始化列表的方式向基类或成员对象的构造函数传递参数**，形式如下：
+
+派生类构造函数名(参数表):基类构造函数名(参数表),成员对象名1(参数表),…{
+    //……
+}
+
+三、构造函数和析构函数调用次序
+**派生类对象的构造**
+
+- 先构造基类
+- 再构造成员
+- 最后构造自身（调用构造函数）
+
+基类构造顺序由派生层次决定：**最远的基类最先构造**
+成员构造顺序和定义顺序符合
+析构函数的析构顺序与构造相反

practical_exercises/10_day_practice/day5/构造函数与析构函数/构造函数调用次序.cpp

@@ -0,0 +1,40 @@
+//Eg6-12.cpp
+#include <iostream>
+using namespace std;
+class A {
+    int x;
+public:
+     A(int i=0) {
+         x=i;
+         cout << "A-----"<<x<<endl;
+     }
+};
+class B {
+    int y;
+public:
+    B(int i) {
+        y=i;
+        cout << "B-----"<<y<<endl;
+    } 
+}; 
+class C {
+    int z;
+public:
+    C(int i) {
+        z=i;
+        cout << "C-----"<<z<<endl;
+    } 
+};
+class D : public B{
+public: 
+    C c1, c2;
+    A *a1 = new A(10);
+    A a0,a4;
+    D( ) : a4(4),c2(2),c1(1),B(1) {
+cout << "D-----5"<<endl;
+    }
+};
+int main(){
+    D d;
+    system("pause");
+}

practical_exercises/10_day_practice/day5/构造函数与析构函数/构造顺序.cpp

@@ -0,0 +1,43 @@
+#include<iostream>
+using namespace std;
+
+/*
+先构造成员
+再构造自身（调用构造函数）
+*/
+
+class A { 
+public: 
+	A() { cout<<"Constructing A"<<endl;} 
+	~A(){ cout<<"Destructing A"<<endl;}
+};
+class B {
+public: 
+	B() { cout<<"Constructing B"<<endl;}
+	~B(){ cout<<"Destructing B"<<endl;}
+};
+
+class C 
+{
+public: 
+	C() { cout<<"Constructing C"<<endl;}
+	~C(){ cout<<"Destructing C"<<endl;}
+	B b;
+	A a;
+};
+
+int main()
+{	
+    C c; 
+    system("pause");
+}
+
+/*
+执行结果：
+Constructing B
+Constructing A
+Constructing C
+Destructing C
+Destructing A
+Destructing B
+*/

practical_exercises/10_day_practice/day5/构造函数与析构函数/没有构造函数的派生类.cpp

@@ -0,0 +1,15 @@
+#include <iostream>
+using namespace std;
+class A { 
+public: 
+    A(){ cout<<"Constructing A"<<endl; } 
+    ~A(){ cout<<"Destructing A"<<endl; }
+};
+class B:public A {
+public: 
+   ~B(){ cout<<"Destructing B"<<endl; }
+};
+int main(){
+    B b;
+    system("pause");
+}

practical_exercises/10_day_practice/day5/构造函数与析构函数/派生类构造函数.cpp

@@ -0,0 +1,27 @@
+#include <iostream>
+using namespace std;
+class Base{
+private:
+    int x;
+public:
+    Base(int a){
+        x=a;
+        cout<<"Base constructor x="<<x<<endl;
+    }
+    ~Base(){ cout<<"Base destructor..."<<endl; }
+};
+class Derived:public  Base{
+private:
+    int y;
+public:
+    Derived(int a,int b):Base(a){       //派生类构造函数的初始化列表
+        y=b;
+        cout<<"Derived constructor y="<<y<<endl;
+    }
+    ~Derived(){ cout<<"Derived destructor..."<<endl; }
+};
+int main(){
+    Derived d(1,2);
+    system("pause");
+    return 0;
+} 

practical_exercises/10_day_practice/day5/构造函数与析构函数/派生类构造函数调用顺序.cpp

@@ -0,0 +1,46 @@
+#include<iostream>
+using namespace std;
+class A { 
+public: 
+	A() { cout<<"Constructing A"<<endl;} 
+	~A(){ cout<<"Destructing A"<<endl;}
+};
+class B {
+public: 
+	B() { cout<<"Constructing B"<<endl;}
+	~B(){ cout<<"Destructing B"<<endl;}
+};
+class C {
+public: 
+	C() { cout<<"Constructing C"<<endl;}
+	~C(){ cout<<"Destructing C"<<endl;}
+};
+class D:public C 
+{
+public: 
+	D() { cout<<"Constructing D"<<endl;}
+	~D(){ cout<<"Destructing D"<<endl;}
+	B b;
+	A a;
+	C c;
+};
+
+int main()
+{
+	D d;
+    system("pause");
+}
+
+/*
+Ö´ĐĐ˝ášűŁş
+Constructing C
+Constructing B
+Constructing A
+Constructing C
+Constructing D
+Destructing D
+Destructing C
+Destructing A
+Destructing B
+Destructing C
+*/

practical_exercises/10_day_practice/day5/构造函数与析构函数/派生类给基类传递参数.cpp

@@ -0,0 +1,24 @@
+#include <iostream>
+using namespace std;
+class Point{
+protected:
+    int x,y;
+public:
+    Point(int a,int b=0) {
+        x=a;  y=b;
+        cout<<"constructing point("<<x<<","<<y<<")"<<endl;
+    }
+};
+class Line:public Point{
+protected:
+    int len;
+public:
+    Line(int a,int b,int l):Point(a,b) {	//构造函数初始化列表
+        len=l;
+        cout<<"Constructing Line,len ..."<<len<<endl;
+    }
+};
+int main(){
+    Line L1(1,2,3);
+    system("pause");
+}

practical_exercises/10_day_practice/day5/继承访问权限/readme.md

@@ -0,0 +1,24 @@
+一、公有继承
+1.基类中protected的成员
+类内部：可以访问
+类的使用者：不能访问
+类的派生类成员：可以访问
+2.派生类不可访问基类的private成员
+3.派生类可访问基类的protected成员
+4.派生类可访问基类的public成员
+
+二、私有继承
+派生类不可访问基类的任何成员与函数
+
+三、保护继承
+派生方式为protected的继承称为保护继承，在这种继承方式下，
+基类的public成员在派生类中会变成protected成员，
+基类的protected和private成员在派生类中保持原来的访问权限
+注意点：当采用保护继承的时候，由于public成员变为protected成员，因此类的使用者不可访问！而派生类可访问！
+
+
+四、派生类对基类成员的访问形式
+1.通过派生类对象直接访问基类成员 
+2.在派生类成员函数中直接访问基类成员 
+3.通过基类名字限定访问被重载的基类成员名  
+

practical_exercises/10_day_practice/day5/继承访问权限/保护成员.cpp

@@ -0,0 +1,36 @@
+/*
+基类中protected的成员
+类内部：可以访问
+类的使用者：不能访问
+类的派生类成员：可以访问
+*/
+#include<iostream>
+class B
+{	
+    private: 
+        int i;
+	protected: 
+        int j;
+	public: 
+        int k;
+};
+class D: public B
+{
+public:
+	void f() 
+	{	
+        i=1;//cannot access 派生类不可访问基类私有成员
+		j=2;//派生类可以访问基类保护成员	
+        k=3;	
+    }
+};
+int main()
+{	
+    B b; 
+	b.i=1;//cannot access 私有成员，类的使用者不能访问
+	b.j=2; //cannot access 保护成员，类的使用者不能访问
+	b.k=3;
+    system("pause");
+    return 0;
+}
+

practical_exercises/10_day_practice/day5/继承访问权限/保护继承.cpp

@@ -0,0 +1,37 @@
+/*
+派生方式为protected的继承称为保护继承，在这种继承方式下，
+基类的public成员在派生类中会变成protected成员，
+基类的protected和private成员在派生类中保持原来的访问权限
+*/
+#include <iostream>
+using namespace std;
+class Base{
+    int x;
+protected:
+    int getx(){ return x; }
+public:
+    void setx(int n){ x=n; }
+    void showx(){ cout<<x<<endl; }
+};
+class Derived:protected Base{
+    int y;
+public:
+    void sety(int n){ y=n; }
+    void sety(){ y=getx();}   //访问基类的保护成员
+    void showy(){ cout<<y<<endl; }
+};
+int main(){
+    Derived obj;
+    obj.setx(10);    //错误
+    obj.sety(20);
+    obj.showx();	 //错误， 
+    obj.showy(); 
+    system("pause");   
+}
+
+/*
+解释：
+如最上面文字所示：保护继承会将基类的public变为protected，而对于protected成员，
+外部去使用保护成员的时候，会报错，所以setx与showx访问错误，而对于派生类，则可直接访问基类的保护成员，
+在派生类中，y=getx()可正常访问！
+*/

practical_exercises/10_day_practice/day5/继承访问权限/公有继承.cpp

@@ -0,0 +1,30 @@
+#include<iostream>
+using namespace std;
+class base{
+	int x;
+public:
+	void setx(int n){	x=n;	}
+	int getx(){	return x;  }
+	void showx()	{	cout<<x<<endl;  }
+};
+//派生类
+class derived:public base{
+	int y;
+public:
+	void sety(int n){	y=n;	}
+	void sety(){	y=getx();    }
+	void showy()
+	{	cout<<y<<endl;   }
+};
+//派生类不可直接访问基类的private成员，可通过基类的共有成员函数访问
+int main()
+{	derived obj;
+	obj.setx(10);	
+    obj.sety(20);
+	obj.showx();	
+    obj.showy();
+	obj.sety();
+	obj.showx();	
+    obj.showy();
+    system("pause");
+}

practical_exercises/10_day_practice/day5/继承访问权限/私有继承.cpp

@@ -0,0 +1,26 @@
+#include <iostream>
+using namespace std;
+class Base{
+    int x;
+public:
+    void setx(int n){x=n; }
+    int getx(){return x; }
+    void showx(){cout<<x<<endl; }
+};
+//私有继承
+//基类的中的public成员在派生类中是private, private成员在派生类中不可访问。
+class derived:private base{
+	int y;
+public:
+	void sety(int n){y=n;	}
+	void sety(){	y=getx();    }
+	void showy()	{	cout<<y<<endl;   }
+};
+int main(){
+	derived obj;
+	obj.setx(10);//cannot access
+	obj.sety(20);
+	obj.showx();//cannot access
+	obj.showy();	
+    system("pause");
+}

practical_exercises/10_day_practice/day5/虚拟继承/readme.md

@@ -0,0 +1,21 @@
+多继承下的二义性：在多继承方式下，派生类继承了多个基类的成员，当两个不同基类拥有同名成员时，容易产生名字冲突问题。
+
+虚拟继承引入的原因：重复基类，派生类间接继承同一基类使得间接基类（Person）在派生类中有多份拷贝，引发二义性。
+
+1、虚拟继承virtual inheritance的定义
+语法
+class derived_class : virtual […] base_class
+虚基类virtual base class
+被虚拟继承的基类
+在其所有的派生类中，仅出现一次
+
+2、虚拟继承的构造次序
+  虚基类的初始化与一般的多重继承的初始化在语法上是一样的，但构造函数的调用顺序不同；
+  若基类由虚基类派生而来，则派生类必须提供对间接基类的构造（即在构造函数初始列表中构造虚基类，无论此虚基类是直接还是间接基类）
+  调用顺序的规定：
+先调用虚基类的构造函数，再调用非虚基类的构造函数
+若同一层次中包含多个虚基类,这些虚基类的构造函数按它们的说明的次序调用
+若虚基类由非基类派生而来,则仍然先调用基类构造函数,再调用派生类构造函数
+3、虚基类由最终派生类初始化 
+在没有虚拟继承的情况下，每个派生类的构造函数只负责其直接基类的初始化。但在虚拟继承方式下，虚基类则由最终派生类的构造函数负责初始化。
+在虚拟继承方式下，若最终派生类的构造函数没有明确调用虚基类的构造函数，编译器就会尝试调用虚基类不需要参数的构造函数（包括缺省、无参和缺省参数的构造函数），如果没找到就会产生编译错误。

practical_exercises/10_day_practice/day5/虚拟继承/例1.cpp

@@ -0,0 +1,18 @@
+#include<iostream>
+using namespace std;
+class A { 
+public:	
+	void vf() {
+		cout<<"I come from class A"<<endl;	}
+};
+class B: public A{};
+class C: public A{};
+class D: public B, public C{};
+
+int main()
+{
+	D d;
+	d.vf ();	// error
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day5/虚拟继承/例2.cpp

@@ -0,0 +1,18 @@
+#include<iostream>
+using namespace std;
+class A { 
+public:	
+	void vf() {
+		cout<<"I come from class A"<<endl;	}
+};
+class B: virtual public A{};
+class C: virtual public A{};
+class D: public B, public C{};
+
+int main()
+{
+	D d;
+	d.vf ();	// okay
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day5/虚拟继承/派生类初始化.cpp

@@ -0,0 +1,33 @@
+#include <iostream>
+using namespace std;
+class A {
+    int a;
+public: 
+    A(int x) {
+        a=x;
+        cout<<"Virtual Bass A..."<<endl; 
+    }
+}; 
+class B:virtual public A {
+public: 
+    B(int i):A(i){ cout<<"Virtual Bass B..."<<endl; }
+};
+class C:virtual public A{
+    int x;
+public:
+    C(int i):A(i){
+        cout<<"Constructing C..."<<endl;
+        x=i; 
+    }
+};
+class ABC:public C, public B {
+public: 
+    //虚基类由最终派生类初始化 
+    ABC(int i,int j,int k):C(i),B(j),A(i) //L1，这里必须对A进行初始化
+        { cout<<"Constructing ABC..."<<endl; }
+}; 
+int main(){
+    ABC obj(1,2,3);
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day5/虚拟继承/虚基类调用次序(重要).cpp

@@ -0,0 +1,31 @@
+//ÖØÒª!!!
+#include <iostream>
+using namespace std;
+class A {
+    int a;
+public: 
+    A(){ cout<<"Constructing A"<<endl; }
+}; 
+class B {
+public: 
+    B(){ cout<<"Constructing B"<<endl;}
+}; 
+class B1:virtual public B ,virtual public A{
+public: 
+    B1(int i){ cout<<"Constructing B1"<<endl; }
+}; 
+class B2:public A,virtual public B {
+public: 
+    B2(int j){ cout<<"Constructing B2"<<endl; }
+};
+class D: public B1, public B2 {
+public:
+    D(int m,int n): B1(m),B2(n){ cout<<"Constructing D"<<endl; }
+    A a;
+}; 
+    
+int main(){
+    D d(1,2);
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day5/调用规则/readme.md

@@ -0,0 +1,21 @@
+一、构造函数和析构函数的构造规则
+
+1、派生类可以不定义构造函数的情况 
+当具有下述情况之一时，派生类可以不定义构造函数。
+基类没有定义任何构造函数。
+基类具有缺省参数的构造函数。
+基类具有无参构造函数。
+2、派生类必须定义构造函数的情况 
+当基类或成员对象所属类只含有带参数的构造函数时，即使派生类本身没有数据成员要初始化，它也必须定义构造函数，并以构造函数初始化列表的方式向基类和成员对象的构造函数传递参数，以实现基类子对象和成员对象的初始化。 
+3、派生类的构造函数只负责直接基类的初始化 
+
+C++语言标准有一条规则：如果派生类的基类同时也是另外一个类的派生类，则每个派生类只负责它的直接基类的构造函数调用。
+这条规则表明当派生类的直接基类只有带参数的构造函数，但没有默认构造函数时（包括缺省参数和无参构造函数），它必须在构造函数的初始化列表中调用其直接基类的构造函数，并向基类的构造函数传递参数，以实现派生类对象中的基类子对象的初始化。
+这条规则有一个例外情况，当派生类存在虚基类时，所有虚基类都由最后的派生类负责初始化。
+
+总结：
+（1）当有多个基类时，将按照它们在继承方式中的声明次序调用，与它们在构造函数初始化列表中的次序无关。当基类A本身又是另一个类B的派生类时，则先调用基类B的构造函数，再调用基类A的构造函数。
+
+（2）当有多个对象成员时，将按它们在派生类中的声明次序调用，与它们在构造函数初始化列表中的次序无关。
+
+（3）当构造函数初始化列表中的基类和对象成员的构造函数调用完成之后，才执行派生类构造函数体中的程序代码。

practical_exercises/10_day_practice/day5/调用规则/直接基类与间接基类.cpp

@@ -0,0 +1,24 @@
+//当同时存在直接基类和间接基类时，每个派生类只负责其直接基类的构造。
+#include <iostream>
+using namespace std;
+class A { 
+    int x;
+public: 
+    A(int aa) {
+        x=aa;
+        cout<<"Constructing A"<<endl;
+    }
+    ~A(){ cout<<"Destructing A"<<endl; }
+};
+class B:public A {
+public: 
+    B(int x):A(x){ cout<<"Constructing B"<<endl; }
+};
+class C :public B{
+public: 
+    C(int y):B(y){ cout<<"Constructing C"<<endl; }
+};
+int main(){
+    C c(1);
+    system("pause");
+}

practical_exercises/10_day_practice/day6/readme.md

@@ -0,0 +1,68 @@
+一、多态性
+多态性：多态就是在同一个类或继承体系结构的基类与派生类中，用同名函数来实现各种不同的功能。
+
+**静态绑定又称静态联编**，是指在编译程序时就根据调用函数提供的信息，把它所对应的具体函数确定下来，即在编译时就把调用函数名与具体函数绑定在一起。 
+
+**动态绑定又称动态联编**，是指在编译程序时还不能确定函数调用所对应的具体函数，只有在程序运行过程中才能够确定函数调用所对应的具体函数，即在程序运行时才把调用函数名与具体函数绑定在一起。
+
+编译时多态性： ---静态联编(连接)----系统在编译时就决定如何实现某一动作,即对某一消息如何处理.静态联编具有执行速度快的优点.在C++中的编译时多态性是通过函数重载和运算符重载实现的。
+运行时多态性： ---动态联编(连接)----系统在运行时动态实现某一动作,即对某一消息在运行过程实现其如何响应.动态联编为系统提供了灵活和高度问题抽象的优点,在C++中的运行时多态性是通过继承和虚函数实现的。
+
+二、虚函数
+
+虚函数的意义
+
+1、基类与派生类的赋值相容
+
+派生类对象可以赋值给基类对象。
+派生类对象的地址可以赋值给指向基类对象的指针。
+派生类对象可以作为基类对象的引用。
+赋值相容的问题：
+不论哪种赋值方式，都只能通过基类对象（或基类对象的指针或引用）访问到派生类对象从基类中继承到的成员， 不能借此访问派生类定义的成员。
+
+2、虚函数使得可以通过基类对象的指针或引用访问派生类定义的成员。
+
+3.Virtual关键字其实质是告知编译系统，被指定为virtual的函数采用动态联编的形式编译。
+
+4.虚函数的虚特征：基类指针指向派生类的对象时，通过该指针访问其虚函数将调用派生类的版本。
+
+- 一旦将某个成员函数声明为虚函数后，它在继承体系中就永远为虚函数了 
+- 如果基类定义了虚函数，当通过基类指针或引用调用派生类对象时，将访问到它们实际所指对象中的虚函数版本。
+- 只有通过基类对象的指针和引用访问派生类对象的虚函数时，才能体现虚函数的特性。
+- 派生类中的虚函数要保持其虚特征，必须与基类虚函数的函数原型完全相同，否则就是普通的重载函数，与基类的虚函数无关。
+- 派生类通过从基类继承的成员函数调用虚函数时，将访问到派生类中的版本。
+- 只有类的非静态成员函数才能被定义为虚函数，类的构造函数和静态成员函数不能定义为虚函数。原因是虚函数在继承层次结构中才能够发生作用，而构造函数、静态成员是不能够被继承的。
+- 内联函数也不能是虚函数。因为内联函数采用的是静态联编的方式，而虚函数是在程序运行时才与具体函数动态绑定的，采用的是动态联编的方式，即使虚函数在类体内被定义，C++编译器也将它视为非内联函数。
+5.基类析构函数几乎总是为虚析构函数。
+why?
+假定使用delete和一个指向派生类的基类指针来销毁派生类对象，如果基类析构函数不为虚,就如一个普通成员函数，delete函数调用的就是基类析构函数。在通过基类对象的引用或指针调用派生类对象时，将致使对象析构不彻底！
+
+三、纯虚函数和抽象类 
+
+1.纯虚函数概念？
+
+仅定义函数原型而不定义其实现的虚函数
+Why pure function?
+实用角度：占位手段place-holder
+方法学：接口定义手段，抽象表达手段
+How?
+class X
+{
+	virtual ret_type func_name (param) = 0;
+}
+2.抽象类概念？
+
+What is an abstract class?
+包含一个或多个纯虚函数的类
+Using abstract class
+**不能实例化抽象类**
+但是可以定义抽象类的指针和引用
+Converting abstract class to concrete class
+定义一个抽象类的派生类
+定义所有纯虚函数
+
+3.C++对抽象类具有以下限定
+
+- 抽象类中含有纯虚函数，由于纯虚函数没有实现代码，所以不能建立抽象类的对象。
+- 抽象类只能作为其他类的基类，可以通过抽象类对象的指针或引用访问到它的派生类对象，实现运行时的多态性。
+- 如果派生类只是简单地继承了抽象类的纯虚函数，而没有重新定义基类的纯虚函数，则派生类也是一个抽象类。

practical_exercises/10_day_practice/day6/纯虚函数和抽象类/抽象类.cpp

@@ -0,0 +1,46 @@
+#include<iostream>
+using namespace std;
+class Figure{
+    protected:
+        double x,y;
+    public:
+        void set(double i, double j){
+            x=i;y=j;
+        }
+        virtual void area()=0;
+};
+
+class Trianle:public Figure{
+    public:
+        void area(){
+            cout<<"三角形面积："<<x*y*0.5<<endl;
+        }
+};
+class Rectangle:public Figure{
+    public:
+        void area(){
+            cout<<"这是矩形，它的面积是："<<x*y<<endl;
+        }
+};
+
+int main(int argc, char const *argv[])
+{
+    //定义抽象类指针
+    Figure *pF=NULL;
+    // Figure f1; 抽象类不能被实例化
+    Rectangle r;
+    Trianle t;
+    t.set(10,20);
+    pF=&t;
+    pF->area();
+    r.set(10,20);
+    pF=&r;
+    pF->area();
+    //定义抽象类引用
+    Figure &rF=t;
+    rF.set(20,20);
+    rF.area();
+    system("pause");
+    return 0;
+}
+

practical_exercises/10_day_practice/day6/虚函数/从基类继承的成员将访问到派生类版本.cpp

@@ -0,0 +1,17 @@
+#include <iostream>
+using namespace std;
+class B{
+public: 
+    void f(){ g(); } 
+    virtual void g(){ cout << "B::g"; }
+};
+class D : public B{
+public: 
+    void g(){ cout << "D::g\n"; }
+};
+int main(){
+    D d;
+    d.f();
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day6/虚函数/编程实例.cpp

@@ -0,0 +1,92 @@
+/*
+某公司有经理、销售员、小时工等多类人员。经理按周计算薪金；销售员每月底薪800元，
+然后加销售提成，每销售1件产品提取销售利润的5%；小时工按小时计算薪金。每类人员都有姓名和身份证号等数据。
+为简化问题，把各类人员的共有信息抽象成基类Employee，其他人员则继承该类的功能。 
+*/
+#include <iostream>
+#include <string>
+using namespace std;
+class Employee{
+    public:
+        Employee(string Name ,string id){ name=Name; Id=id; }
+        string getName(){ return name; }			//返回姓名
+        string getID(){ return Id; }			//返回身份证号
+        float getSalary(){ return 0.0; }			//返回薪水
+        void print(){		//输出姓名和身份证号
+            cout<<"姓名: "<<name<<"\t\t 编号: "<<Id<<endl;
+    }
+    private:
+        string name;
+        string Id;
+};
+class Manager:public Employee{
+    public:
+        Manager(string Name,string id,int week):Employee(Name,id){
+            WeeklySalary=week*1000;
+        }
+        float getSalary(){ return WeeklySalary; }	//获取经理的周薪
+        void print(){			//打印经理姓名、身份证、周薪
+            cout<<"经理："<<getName()<<"\t\t 编号: "<<getID()
+                <<"\t\t 总工资: "<<getSalary()<<endl;
+            }
+    private:
+        float WeeklySalary;					//周薪
+};
+
+
+class SaleWorker:public Employee{
+    public:
+        SaleWorker(string name,string id,int profit,int x):Employee(name,id){
+            workerMoney=baseMoney+x*0.05*profit;
+        }
+        float getSalary(){
+            return workerMoney;
+        }
+        void print(){
+            cout<<"销售员："<<getName()<<"\t\t 编号: "<<getID()
+                <<"\t\t 总工资: "<<getSalary()<<endl;
+        }
+    private:
+        float baseMoney=800.0;
+        float workerMoney;
+};
+class HourWorker:public Employee{
+    public:
+        HourWorker(string name,string id,int h):Employee(name,id){
+            TotalMoney=h*hourMoney;
+        }
+        float getSalary(){
+            return TotalMoney;
+        }
+        void print(){
+            cout<<"小时工："<<getName()<<"\t\t 编号: "<<getID()
+                <<"\t\t 总工资: "<<getSalary()<<endl;
+        }
+    private:
+        float hourMoney=100.0;
+        float TotalMoney;
+};
+
+
+int main(){
+    cout<<"请输入工作周：";
+    int week;
+    cin>>week;
+    Manager m("小王","11111111",week);
+    m.print();
+    cout<<"请输入销售利润：";
+    int profit;
+    cin>>profit;
+    cout<<"请输入销售件数：";
+    int x;
+    cin>>x;
+    SaleWorker s("小李","222222",profit,x);
+    s.print();
+    cout<<"请输入工作小时：";
+    int hour;
+    cin>>hour;
+    HourWorker h("小何","333333",hour);
+    h.print();
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day6/虚函数/虚函数例子.cpp

@@ -0,0 +1,66 @@
+
+//Eg7-1.cpp
+//基类指针或引用指向派生类对象时,虚函数与非虚函数区别：
+//声明Employee的print为虚函数，则可访问到Manager的print函数，非虚函数，则只能访问到Employee的print
+#include<iostream>
+#include<string>
+using namespace std;
+class Employee{
+    public:
+        Employee(string name, string id);
+        string getName();
+        string getId();
+        float getSalary();
+        virtual void print();
+    private:
+        string Name;
+        string Id;
+};
+Employee::Employee(string name,string id){
+    Name=name;
+    Id=id;
+}
+string Employee::getName(){
+    return Name;
+}
+string Employee::getId(){
+    return Id;
+}
+float Employee::getSalary(){
+    return 0.0;
+}
+void Employee::print(){
+    cout<<"姓名："<<Name<<"\t"<<"编号："<<Id<<endl;
+}
+
+class Manager:public Employee{
+    public:
+        Manager(string name,string id,float s=0.0):Employee(name,id){
+            weeklySalary=s;
+        }
+        void setSalary(float s) { weeklySalary=s; }	//设置经理的周薪
+        float getSalary(){ return weeklySalary; }	//获取经理的周薪
+        void print(){			//打印经理姓名、身份证、周薪
+            cout<<"经理："<<getName()<<"\t\t 编号: "<<getId()<<"\t\t 周工资: "<<getSalary()<<endl;
+        }
+    private:
+        float weeklySalary; //周薪
+};
+
+
+/*
+不论哪种赋值方式，都只能通过基类对象（或基类对象的指针或引用）访问到派生类对象从基类中继承到的成员， 
+不能借此访问派生类定义的成员。而虚函数使得可以通过基类对象的指针或引用访问派生类定义的成员。
+*/
+int main(){
+    Employee e("小米","NO0001"),*pM;
+    Manager m("小汪","NO0002",128);
+    m.print();
+    pM=&m;
+    pM->print();
+    Employee &rM=m; 
+    rM.print();
+    system("pause");
+    return 0;
+}
+//Virtual关键字其实质是告知编译系统，被指定为virtual的函数采用动态联编的形式编译。

practical_exercises/10_day_practice/day6/虚函数/虚函数特性.cpp

@@ -0,0 +1,30 @@
+#include <iostream>
+#include<string>
+using namespace std;
+class A { 
+public: 
+    void f(int i){cout<<"…A"<<endl;}; 
+};
+class B: public A { 
+public:
+    virtual void f(int i){cout<<"…B"<<endl;}
+};
+class C: public B {
+public: 
+    void f(int i){cout<<"…C"<<endl;}
+};
+//一旦将某个成员函数声明为虚函数后，它在继承体系中就永远为虚函数了 
+class D: public C{
+public:
+    void f (int){cout<<"…D"<<endl;}
+};
+int main(){
+    A *pA,a;
+    B *pB, b;    C c;    D d;
+    pA=&a;    pA->f(1);		//调用A::f
+    pB=&b;    pB->f(1);		//调用A::f
+    pB=&c;    pB->f(1);		//调用A::f
+    pB=&d;    pB->f(1);		//调用A::f
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day6/虚函数/虚析构函数.cpp

@@ -0,0 +1,22 @@
+
+#include <iostream>
+using namespace std;
+class A{
+public:
+     virtual ~A(){ cout<<"call A::~A()"<<endl; }
+};
+class B:public A{
+    char *buf;
+public:
+    B(int i){buf=new char[i];}
+     ~B(){
+        delete [] buf;
+        cout<<"call B::~()"<<endl;
+}
+};
+int main(){
+    A* a=new B(10);
+    delete a;
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day7/()运算符/重载()的时钟.cpp

@@ -0,0 +1,25 @@
+#include <iostream>
+using namespace std;
+class Time{
+private:
+    int hh,mm,ss;
+public:
+    Time(int h=0,int m=0,int s=0):hh(h),mm(m),ss(s){}
+    void operator()(int h,int m,int s) {
+        hh=h;
+        mm=m;
+        ss=s;
+    }
+    void ShowTime(){
+        cout<<hh<<":"<<mm<<":"<<ss<<endl;
+    }
+};
+int main(){
+    Time t1(12,10,11);
+    t1.ShowTime();
+    t1.operator()(23,20,34);	
+    t1.ShowTime();
+    t1(10,10,10);               	
+    t1.ShowTime();
+    system("pause");
+}

practical_exercises/10_day_practice/day7/=号运算符/=例题.cpp

@@ -0,0 +1,16 @@
+//例题ch.cppi
+#include <iostream>
+using namespace std;
+class X{
+public:
+	X &operator = (const X & x) 
+	{cout << "a:"; return *this;};
+};
+int main ()
+{
+	X obj1, obj2, obj3;
+	obj1 = obj2;          //调用重载“=”
+	obj1.operator= (obj2); //调用重载“=”
+	obj1 = obj2 = obj3;    //调用重载“=”
+    system("pause");
+}

practical_exercises/10_day_practice/day7/[]与()例题/example1.cpp

@@ -0,0 +1,21 @@
+#include<iostream>
+using namespace std;
+class X
+{public:
+	int operator() (int i=0)
+	{ cout << "X::operator(" << i << ")" << endl; return i; };
+	int operator() (int i, int j)
+	{ cout << "X::operator(" << i << "," << j << ")" << endl; 
+			return i; };
+	int operator[] (int i)
+	{ cout << "X::operator[" << i << "]" << endl; return i; };
+	int operator[] (char * cp)
+	{ cout << "X::operator[" << cp << "]" << endl; return 0; };
+};
+int main (void)
+{	X obj;	int i = obj (obj (1), 2);
+	int a = obj[i];	int b = obj["abcd"];
+    cout<<"a="<<a<<endl;
+    cout<<"b="<<b<<endl;
+    system("pause");
+}

practical_exercises/10_day_practice/day7/[]运算符/[]例题(重点).cpp

@@ -0,0 +1,50 @@
+//Eg8-9.cpp
+#include <iostream>
+#include <cstring>
+using namespace std;
+struct Person{                		//职工基本信息的结构
+		double salary;
+		char *name;
+};
+class SalaryManaege{
+		Person *employ;          	 //存放职工信息的数组
+		int max;                  		//数组下标上界
+		int n;                    		//数组中的实际职工人数
+public:
+	SalaryManaege(int Max=0){
+		max=Max;
+		n=0;
+		employ=new Person[max];
+	}
+    double &operator[](char *Name) {       	//重载[]，返回引用
+		Person *p;
+		for(p=employ;p<employ+n;p++)   
+			//如果存在处理   	
+			if(strcmp(p->name,Name)==0) 
+				return p->salary;
+		//不存在情况处理
+		p=employ + n++; 
+		p->name=new char[strlen(Name)+1];
+		strcpy(p->name,Name);
+		p->salary=0;
+		return p->salary;
+	}
+
+	void display(){      								
+		for(int i=0;i<n;i++)
+			cout<<employ[i].name<<"   "<<employ[i].salary<<endl;
+		}
+};
+int main(){
+    SalaryManaege s(3);
+    s["张三"]=2188.88;
+    s["里斯"]=1230.07;
+    s["王无"]=3200.97;
+    cout<<"张三\t"<<s["张三"]<<endl;          cout<<"里斯\t"<<s["里斯"]<<endl;
+    cout<<"王无\t"<<s["王无"]<<endl;
+  
+    cout<<"-------下为display的输出--------\n\n";
+    s.display();
+    system("pause");
+}
+

practical_exercises/10_day_practice/day7/readme.md

@@ -0,0 +1,145 @@
+运算符重载是C++的一项强大功能。通过重载，可以扩展C++运算符的功能，使它们能够操作用户自定义的数据类型，增加程序代码的直观性和可读性。
+
+本章主要介绍 类成员运算符重载与友元运算符重载,  二元运算符与一元运算符重载,  运算符++、--、[]、（）重载,  this指针与运算符重载及 流运算符<<和>>的重载
+
+一、重载二元运算符
+
+1、二元运算符的调用形式与解析
+
+aa@bb    可解释成  aa.operator@(bb)
+               或解释成 operator@(aa,bb)
+
+如果两者都有定义,就按照重载解析
+
+```c++
+class X{
+public:
+	void operator+(int);
+	X(int);
+};
+void operator+(X,X);
+void operator+(X,double);
+```
+2、类运算符重载形式
+
+（1）非静态成员运算符重载
+
+以类成员形式重载的运算符参数比实际参数少一个，第1个参数是以this指针隐式传递的。 
+
+```c++
+class Complex{
+		double real,image;
+public:
+		Complex operator+(Complex b){……}
+......
+};
+```
+（2） 友元运算符重载
+
+如果将运算符函数作为类的友元重载，它需要的参数个数就与运算符实际需要的参数个数相同。比如，若用友元函数重载Complex类的加法运算符，则形式如下：
+
+```c++
+class Complex{
+……
+		friend Complex operator+(Complex a,Complex b);		//声明
+//......
+};
+
+Complex  operator+(Complex a,Complex b){……}     		//定义
+```
+
+二、重载一元运算符 
+
+1、一元运算符
+
+一元运算符只需要一个运算参数，如取地址运算符（&）、负数（?）、自增加（++）等。
+
+2、一元运算符常见调用形式为：
+
+@a     或    a@ 		//隐式调用形式
+
+a.operator@()                   	// 显式调用一元运算符@
+
+其中的@代表一元运算符，a代表操作数。
+
+@a代表前缀一元运算，如“++a”；
+
+a@表示后缀运算，如“a++”。
+
+3、@a将被C++解释为下面的形式之一
+
+a.operator@()
+
+operator@(a) 
+
+4.一元运算符作为类成员函数重载时不需要参数，其形式如下：
+
+```c++
+class X{
+……
+		T operator@(){……};
+}
+```
+T是运算符@的返回类型。从形式上看，作为类成员函数重载的一元运算符没有参数，但实际上它包含了一个隐含参数
+
+即调用对象的this指针。
+
+5.前自增(减)与后自增(减)
+
+C++编译器可以通过在运算符函数参数表中是否插入关键字int 来区分这两种方式
+
+```c++
+//前缀
+operator -- ();
+operator -- (X & x);
+//后缀
+operator -- (int);
+operator -- (X & x, int);
+```
+三、重载赋值运算符=
+
+1、赋值运算符“=”的重载特殊性
+
+赋值运算进行时将调用此运算符
+
+只能用成员函数重载
+
+如果需要而没有定义时，编译器自动生成，该版本进行bit-by-bit拷贝
+
+四、重载赋值运算符[]
+
+1、[ ]是一个二元运算符，其重载形式如下：
+
+```c++
+class X{
+……
+		X& operator[](int n);
+};
+```
+2、重载[]需要注意的问题
+- []是一个二元运算符，其第1个参数是通过对象的this指针传递的，第2个参数代表数组的下标
+- 由于[]既可以出现在赋值符“=”的左边，也可以出现在赋值符“=”的右边，所以重载运算符[]时常返回引用。
+- **[]只能被重载为类的非静态成员函数，不能被重载为友元和普通函数**。
+
+五、重载( ) 
+
+1、运算符( )是函数调用运算符，也能被重载。且只能被重载为类的成员函数。
+
+2、运算符( )的重载形式如下：
+
+```c++
+class X{
+……
+		X& operator( )(参数表);
+}；
+```
+
+其中的参数表可以包括任意多个参数。
+
+3、运算符( )的调用形式如下：
+
+X Obj;              		//对象定义
+
+Obj()(参数表);  		//调用形式1
+
+Obj(参数表);       		//调用形式2

practical_exercises/10_day_practice/day7/一元运算符/秒钟自增运算.cpp

@@ -0,0 +1,76 @@
+//设计一个时间类Time，它能够完成秒钟的自增运算。
+
+#include<iostream>
+using namespace std;
+
+class Time{
+    private:
+        int hour,minute,second;
+    public:
+        Time(int h,int m, int s);
+        Time operator++();
+        //友元重载需要参数
+        friend Time operator--(Time &t);
+        void display(); 
+};
+
+Time::Time(int h, int m, int s){
+    hour=h;
+    minute=m;
+    second=s;
+    if (hour>=24)
+        hour=0;
+    if (minute>=60)
+        minute=0;
+    if (second>=60)
+        second=0;
+}
+
+Time Time::operator++(){
+    ++second;
+    if (second>=60){
+        second=0;
+        ++minute;
+        if(minute>=60){
+            minute=0;
+            ++hour;
+            if(hour>=24)
+                hour=0;
+        }
+    }
+    return *this;       
+}
+Time operator--(Time &t){
+    --t.second;
+    if (t.second>=60){
+        t.second=0;
+        ++t.minute;
+        if(t.minute>=60){
+            t.minute=0;
+            ++t.hour;
+            if(t.hour>=24)
+                t.hour=0;
+        }
+    }
+    return t;  
+}
+void Time::display(){
+    cout<<hour<<":"<<minute<<":"<<second<<endl;
+}
+int main(int argc, char const *argv[])
+{
+    Time t1(23,59,59);
+    t1.display();
+    ++t1; //隐式调用
+    t1.display();
+    t1.operator++(); //显式调用
+    t1.display();
+    Time t2(24,60,60);
+    t2.display();
+    ++t2;
+    t2.display();
+    --t2;
+    t2.display();
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day7/一元运算符/计数器前后自增.cpp

@@ -0,0 +1,47 @@
+//设计一个计数器counter，用类成员重载自增运算符实现计数器的自增，用友元重载实现计数器的自减。
+#include<iostream>
+using namespace std;
+class Counter{
+    private:
+        int n;
+    public:
+        Counter(int i=0):n(i){};
+        Counter operator++();
+        Counter operator++(int);
+        friend Counter operator--(Counter &c);
+        friend Counter operator--(Counter &c,int);
+        void display();
+};
+Counter Counter::operator++(){
+    ++n;
+    return *this;
+}
+Counter Counter::operator++(int){
+    n++;
+    return *this;
+}
+Counter operator--(Counter &c){
+    --c.n;
+    return c;
+}
+Counter operator--(Counter &c,int){
+    c.n--;
+    return c;
+}
+void Counter::display(){
+    cout<<"counter number="<<n<<endl;
+}
+int main(int argc, char const *argv[])
+{
+    Counter a;
+    ++a;
+    a.display();
+    a++;
+    a.display();
+    --a;
+    a.display();
+    a--;
+    a.display();
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day7/二元运算符/1.类运算符重载.cpp

@@ -0,0 +1,67 @@
+//有复数类Complex，利用运算符重载实现复数的加、减、乘、除等复数运算。
+#include<iostream>
+using namespace std;
+class Complex {
+    private:
+        double r,i;
+    public:
+        Complex(double R=0,double I=0):r(R),i(I){};
+        Complex operator+(Complex b);
+        Complex operator-(Complex b);
+        Complex operator*(Complex b);
+        Complex operator/(Complex b);
+        void display();
+};
+
+Complex Complex::operator +(Complex b)
+{
+    return Complex(r+b.r,i+b.i);
+}
+Complex Complex::operator -(Complex b)
+{
+    return Complex(r-b.r,i-b.i);
+}
+//求复数相乘的算法
+Complex Complex::operator *(Complex b)
+{   
+    Complex t;
+    t.r=r*b.r-i*b.i;
+    t.i=r*b.i+i*b.r;
+    return t;
+}
+//求复数相除的算法
+Complex Complex::operator /(Complex b) {
+    Complex t;
+    double x;
+    x=1/(b.r*b.r+b.i*b.i);
+    t.r=x*(r*b.r+i*b.i);
+    t.i=x*(i*b.r-r*b.i);
+    return t;
+}
+void Complex::display(){
+    cout<<r;
+    if (i>0) cout<<"+";
+    if (i!=0) cout<<i<<"i"<<endl;
+    //}display();
+};
+
+int main(void) {
+    Complex c1(1,2),c2(3,4),c3,c4,c5,c6;
+    Complex a,b(2,3);
+    a=b+2;       			//正确
+    // a=2+b;       			//错误   
+    a.display();  
+    c3=c1+c2;
+    c4=c1-c2;
+    c5=c1*c2;
+    c6=c1/c2;
+    c1.display();
+    c2.display();
+    c3.display();
+    c4.display();
+    c5.display();
+    c6.display();
+    system("pause");
+    return 0;
+}
+

practical_exercises/10_day_practice/day7/二元运算符/2.友元运算符实现.cpp

@@ -0,0 +1,84 @@
+
+/*
+在C++的标准命名空间std中预定义了复数类Complex，
+并且通过友元重载了Complex的各种运算，包括本程序中重载的+、-、*、/。
+若使用using namespace std将std名字空间引入本程序，
+则本程序中的Complex将与std名字空间中的Complex类的运算符重载函数产生冲突，引起编译错误。
+*/
+/*
+对于不要求左值且可以交换参数次序的运算符（如+、-、*、/ 等运算符），
+最好用非成员形式（包括友元和普通函数）的重载运算符函数实现。
+*/
+
+//解决前面的2+b问题。
+#include<iostream>
+
+
+class Complex{
+    private:
+        double r,i;
+    public:
+        Complex(double R=0,double I=0):r(R),i(I){};
+        friend Complex operator+(Complex a, Complex b);
+        friend Complex operator-(Complex a, Complex b);
+        friend Complex operator*(Complex a, Complex b);
+        friend Complex operator/(Complex a, Complex b);
+
+        friend Complex operator+(Complex a,double b){
+            return Complex(a.r+b,a.i);
+        }
+        friend Complex operator+(double a,Complex b){
+            return Complex(a+b.r,b.i);
+        }
+        
+        void display();
+};
+
+Complex operator+(Complex a, Complex b){
+    return Complex(a.r+b.r,a.i+b.i); 
+}
+Complex operator-(Complex a, Complex b){
+    return Complex(a.r-b.r,a.i-b.i);
+}
+Complex operator*(Complex a, Complex b){
+    Complex t;
+    t.r = a.r*b.r-a.i*b.i;
+    t.i = a.r*b.i+a.i*b.r;
+}
+Complex operator/(Complex a, Complex b){
+    Complex t;
+    double x;
+    x = 1/(b.r*b.r+b.i*b.i);
+    t.r = x*(a.r*b.r+a.i*b.i);
+    t.i = x*(a.i*b.r-a.r*b.i);
+    return t;
+}
+
+void Complex::display(){
+    std::cout<<r;
+    if(i>0)
+        std::cout<<"+";
+    if(i!=0)
+        std::cout<<i<<"i"<<std::endl;
+}
+int main(void) {
+    Complex c1(1,2),c2(3,4),c3,c4,c5,c6; 
+    Complex a,b(2,3);
+    Complex a1=b+2;       			
+    Complex a2=2+b;       	 
+    a1.display();
+    a2.display();  
+    c3=c1+c2;
+    c4=c1-c2;
+    c5=c1*c2;
+    c6=c1/c2;
+    c1.display();
+    c2.display();
+    c3.display();
+    c4.display();
+    c5.display();
+    c6.display();
+    system("pause");
+    return 0;
+}
+

practical_exercises/10_day_practice/day7/综合例题/重要.cpp

@@ -0,0 +1,70 @@
+//设计一个字符串类String，通过运算符重载实现字符串的输入、输出以及+=、==、!=、<、>、>=、[ ]等运算。
+#include <iostream>
+#include <cstring>
+using namespace std;
+class String {
+private:
+int length;                     		//字符串长度
+char *sPtr;                     		//存放字符串的指针
+void setString( const char *s2);	
+friend ostream &operator<<(ostream &os, const String &s); 
+friend istream &operator>>(istream &is, String &s);  //重载输入运算符
+public:
+    String( const char * = "" );                   
+    const String &operator=(const String &R); 		//重载赋值运算符 =
+    const String &operator+=(const String &R);		//字符串的连接 +=
+    bool operator==(const String &R);				//字符串的相等比较 ==
+    bool operator!=(const String &R);				//字符串的不等比较 !=
+    bool operator!() ;               				//判定字符串是否为空
+    bool operator<(const String &R) const;     		//字符串的小于比较 <
+    bool operator>(const String &R);                	//字符串的大于比较 >
+    bool operator>=(const String &R);             	//字符串的大于等于比较
+    char &operator[](int);                         	//字符串的下标运算
+    ~String();  
+};
+const String &String::operator+=(const String &R) {
+    char *temp = sPtr;              
+    length += R.length;           
+    sPtr = new char[length+1]; 
+    strcpy(sPtr,temp );           
+    strcat(sPtr,R.sPtr );         
+    delete [] temp;                 
+    return *this;                         
+}
+bool String::operator==(const String &R){return strcmp(sPtr,R.sPtr)==0;}
+bool String::operator!=(const String & R){return !(*this==R);}
+bool String::operator!(){return length ==0;}
+bool String::operator<(const String &R)const{return strcmp(sPtr,R.sPtr)<0;}
+bool String::operator>(const String &R){return R<*this;}
+bool String::operator>=(const String &R){return !(*this<R);}
+char &String::operator[](int subscript){return sPtr[subscript];}
+int main(){
+    String s1("happy"),s2("new year"),s3;
+    cout << "s1 is " << s1 << "\ns2 is " << s2 << "\ns3 is " << s3       
+    << "\n比较s2和s1:"
+    << "\ns2 ==s1结果是 " << ( s2 == s1 ? "true" : "false")
+    << "\ns2 != s1结果是 " << ( s2 != s1 ? "true" : "false")
+    << "\ns2 >  s1结果是 " << ( s2 >  s1 ? "true" : "false") 
+    << "\ns2 <  s1结果是 " << ( s2 <  s1 ? "true" : "false") 
+    << "\ns2 >= s1结果是 " << ( s2 >= s1 ? "true" : "false");
+    cout << "\n\n测试s3是否为空: ";                         	
+    if (!s3){
+        cout << "s3是空串"<<endl;                           	//L3
+        cout<<"把s1赋给s3的结果是：";                    		       	
+        s3 = s1;                                         
+        cout << "s3=" << s3 << "\n";                          	//L5
+    }
+    cout << "s1 += s2 的结果是：s1=";                      	//L6
+    s1 += s2;                                       
+    cout << s1;                                             		//L7
+                                                        
+    cout << "\ns1 +=  to you 的结果是：";                     	//L8
+    s1 += " to you";                               
+    cout << "s1 = " << s1 <<endl;                              	//L9
+    s1[0] = 'H';      
+    s1[6] = 'N';
+    s1[10] = 'Y';
+    cout << "s1 = " << s1 << "\n";                               //L10
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day8/STL/map_se.cpp

@@ -0,0 +1,48 @@
+#include<iostream>
+#include<string>
+#include<map>
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+    string name[]={"张三","李四","王麻子"};
+    double salary[]={1200,2000,1450};
+    map<string,double>sal;
+    map<string,double>::iterator p;
+    for(int i=0;i<3;i++){
+        sal.insert(make_pair(name[i],salary[i]));
+    }
+    sal["tom"]=6156;
+    sal["bob"]=5999;
+    for(p=sal.begin();p!=sal.end();p++){
+        cout<<p->first<<"\t"<<p->second<<endl;
+    }
+    string person;
+    cout<<"输入查找人员的姓名:";
+    cin>>person;
+    int flag=1;
+    for(p=sal.begin();p!=sal.end();p++)
+        if(p->first==person){
+            cout<<p->second<<endl;    
+            flag=0; 
+        }
+    if(flag)
+        cout<<"没查找到对应的结果！"<<endl; 
+
+    cout<<"输入待删除的人员的姓名:";
+    cin>>person;
+    map<string,double>::iterator it;
+    it = sal.find(person);
+    if(it!=sal.end()){
+        cout<<"查找成功："<<(*it).first<<":"<<(*it).second<<endl;
+        sal.erase(it);
+        cout<<"删除成功"<<endl;
+    }
+    cout<<"删除后的结果为"<<endl;
+    for(p=sal.begin();p!=sal.end();p++){
+        cout<<p->first<<p->second<<endl;
+    }
+
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day8/readme.md

@@ -0,0 +1,187 @@
+模板（template）是C++实现代码重用机制的重要工具，是泛型技术（即与数据类型无关的通用程序设计技术）的基础。
+模板是C++中相对较新的?语言机制，它实现了与具体数据类型无关的通用算法程序设计，能够提高软件开发的效率，是程序代码复用的强有力工具。 
+
+本章主要介绍了函数模板和类模板两类，以及STL库中的几个常用模板数据类型。
+一、模板 
+1、模板概念
+模板是对具有相同特性的函数或类的再抽象，模板是一种参数多态性的工具，可以为逻辑功能相同而类型不同的程序提供一种代码共享的机制。
+一个模板并非一个实实在在的函数或类，仅仅是一个函数或类的描述，是参数化的函数和类。
+2、模板分类
+函数模板
+类模板
+3.函数模板与模板函数
+函数模板提供了一种通用的函数行为，该函数行为可以用多种不同的数据类型进行调用，编译器会据调用类型自动将它实例化为具体数据类型的函数代码，也就是说函数模板代表了一个函数家族。
+与普通函数相比，函数模板中某些函数元素的数据类型是未确定的，这些元素的类型将在使用时被参数化；与重载函数相比，函数模板不需要程序员重复编写函数代码，它可以自动生成许多功能相同但参数和返回值类型不同的函数。
+二、函数模板
+1、函数模板的定义
+```c++
+template <class T1, class T2,…>返回类型 函数名(参数表){
+   	…… 								//函数模板定义体
+}
+```
+template是定义模板的关键字；写在一对<>中的T1，T2，…是模板参数，其中的class表示其后的参数可以是任意类型。
+模板参数常称为类型参数或类属参数，在模板实例化（即调用模板函数时）时需要传递的实参是一种数据类型，如int或double之类。
+函数模板的参数表中常常出现模板参数，如T1，T2
+2、使用函数模板的注意事项
+① 在定义模板时，不允许template语句与函数模板定义之间有任何其他语句。
+```c++
+template <class T>
+int x;                 //错误，不允许在此位置有任何语句
+T min(T a,T b){…}
+```
+② 函数模板可以有多个类型参数，但每个类型参数都必须用关键字class或typename限定。此外，模板参数中还可以出现确定类型参数，称为非类型参数。例：
+```c++
+template <class T1,class T2,class T3,int T4>
+T1 fx(T1 a, T 2 b, T3 c){…}
+```
+在传递实参时，非类型参数T4只能使用常量
+③ 不要把这里的class与类的声明关键字class混淆在一起，虽然它们由相同的字母组成，但含义是不同的。这里的class表示T是一个类型参数，可以是任何数据类型，如int、float、char等，或者用户定义的struct、enum或class等自定义数据类型。
+④ 为了区别类与模板参数中的类型关键字class，标准C++提出?了用typename作为模板参数的类型关键字，同时也支持使用class。比如，把min定义的template <class T>写成下面的形式是完全等价的：
+```c++
+template <typename T> 
+T min(T a,T b){…}
+```
+
+3.函数模板的实例化
+- 实例化发生的时机
+模板实例化发生在调用模板函数时。当编译器遇到程序中对函数模板的调用时，它才会根据调用语句中实参的具体类型，确定模板参数的数据类型，并用此类型替换函数模板中的模板参数，生成能够处理该类型的函数代码，即模板函数。
+- 当多次发生类型相同的参数调用时，只在第1次进行实例化。假设有下面的函数调用：
+```c++
+int x=min(2,3);     
+int y=min(3,9);
+int z=min(8.5);
+```
+编译器只在第1次调用时生成模板函数，当之后遇到相同类型的参数调用时，不再生成其他模板函数，它将调用第1次实例化生成的模板函数。
+
+- 实例化的方式
+
+**隐式实例化**
+
+编译器能够判断模板参数类型时，自动实例化函数模板为模板函数
+```c++
+template <typename T> T max (T, T);
+…
+int i = max (1, 2); 
+float f = max (1.0, 2.0);
+char ch = max (‘a’, ‘A’);
+…
+```
+隐式实例化，表面上是在调用模板，实际上是调用其实例
+
+**显示实例化explicit instantiation**
+时机,编译器不能判断模板参数类型或常量值
+需要使用特定数据类型实例化
+语法形式::
+模板名称<数据类型,…,常量值,…> (参数)
+```c++
+template <class T> T max (T, T);
+…
+int i = max (1, ‘2’); 
+// error: data type can’t be deduced
+int i = max<int> (1, ‘2’);
+…
+```
+4.函数模板的特化
+- 特化的原因
+但在某些情况下，模板描述的通用算法不适合特定的场合（数据类型等）
+比如：如max函数
+```c++
+char * cp = max (“abcd”, “1234”);
+实例化为：char * max (char * a, char * b){return a > b ? a : b;}
+```
+这肯定是有问题的，因为字符串的比较为：
+```c++
+char * max (char * a, char * b)
+{	return strcmp(a, b)>0 ? a : b;   }
+```
+- 特化
+所谓特化，就是针对模板不能处理的特殊数据类型，编写与模板同名的特殊函数专门处理这些数据类型。
+模板特化的定义形式：
+template <> 返回类型 函数名<特化的数据类型>(参数表) {
+		…… 							
+}
+说明：
+① template < >是模板特化的关键字，< >中不需要任何内容；
+② 函数名后的< >中是需要特化处理的数据类型。
+
+5.说明
+① 当程序中同时存在模板和它的特化时，特化将被优先调用；
+② 在同一个程序中，除了函数模板和它的特化外，还可以有同名的普通函数。其区别在于C++会对普通函数的调用实参进行隐式的类型转换，但不会对模板函数及特化函数的参数进行任何形式的类型转换。
+6.调用顺序
+当同一程序中具有模板与普通函数时，其匹配顺序如下：
+完全匹配的非模板函数
+完全匹配的模板函数
+类型相容的非模板函数
+三、类模板
+1.类模板的概念
+类模板可用来设计结构和成员函数完全相同，但所处理的数据类型不同的通用类。
+如栈，存在
+双精度栈：
+```c++
+class doubleStack{
+    private:
+    double data[size];
+    ……
+};
+```
+字符栈：
+```c++
+class charStack{
+    private:
+    char data[size];
+    ……
+};
+```
+这些栈除了数据类型之外，操作完全相同，就可用类模板实现。
+
+2.类模板的声明
+```c++
+template<class T1,class T2,…>
+class 类名{
+    	……								// 类成员的声明与定义
+}
+```
+其中T1、T2是类型参数
+类模板中可以有多个模板参数，包括类型参数和非类型参数
+
+3.非类型参数
+
+非类型参数是指某种具体的数据类型，在调用模板时只能为其提供用相应类型的常数值。非类型参数是受限制的，通常可以是整型、枚举型、对象或函数的引用，以及对象、函数或类成员的指针，**但不允许用浮点型（或双精度型）、类对象或void作为非类型参数**。
+
+在下面的模板参数表中，T1、T2是类型参数，T3是非类型参数。
+```c++
+template<class T1,class T2,int T3>
+```
+在实例化时，必须为T1、T2提供一种数据类型，为T3指定一个整常数（如10），该模板才能被正确地实例化。
+
+4.类模板的成员函数的定义
+方法1：在类模板外定义，语法
+template <模板参数列表> 返回值类型 类模板名<模板参数名表>::成员函数名 (参数列表){	……};
+方法2：成员函数定义，与常规成员函数的定义类似，另外
+“模板参数列表”引入的“类型标识符”作为数据类型使用
+“模板参数列表”引入的“普通数据类型常量”作为常量使用
+5.类模板特化
+
+特化
+解决例9-9的方法是特化。即用与该模板相同的名字为某种数据类型专门重写一个模板类。 
+类模板有两种特化方式：一种是特化整个类模板，另一种是特化个别成员函数 
+特化成员函数的方法：
+```c++
+template <> 返回类型 类模板名<特化的数据类型>::特化成员函数名(参数表){
+   …… 								//函数定义体
+}
+```
+
+```c++
+template<>  void Array<char *>::Sort(){
+    for(int i=0;i<Size-1;i++){
+        int p=i;
+        for(int j=i+1;j<Size;j++)
+            if(strcmp(a[p],a[j])<0)
+                p=j;
+        char* t=a[p];
+        a[p]=a[i];
+        a[i]=t;
+    }
+}
+```

practical_exercises/10_day_practice/day8/函数模板/例1.cpp

@@ -0,0 +1,36 @@
+//函数模板参数可以是类属参数，也可以包括普通类型的参数
+#include<iostream>
+using namespace std;
+
+
+template <class T>
+//实现降序
+void sort(T &a, int n){
+    for (int i=0;i<n;i++){
+        int p=i;
+        for (int j=i;j<n;j++)
+            if(a[p]<a[j])
+                p=j;
+        int t=a[i];	
+        a[i]=a[p];		
+        a[p]=t;
+    }
+}
+template <class T>
+void display(T& a,int n) {
+    for(int i=0;i<n;i++)
+        cout<<a[i]<<"\t"<<endl;
+}
+
+
+int main(int argc, char const *argv[])
+{
+    int a[]={1,41,2,5,8,21,23};
+    char b[]={'a','x','y','e','q','g','o','u'};
+    sort(a,7);
+    sort(b,8);
+    display(a,7);
+    display(b,8);
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day8/函数模板/模板特化.cpp

@@ -0,0 +1,26 @@
+//Eg9-6.cpp
+#include <iostream>
+#include<cstring>
+using namespace std;
+template <class T>
+T Max(T a,T b) {
+    return (a>b)?a:b;
+}
+//特化
+//template <> 返回类型 函数名<特化的数据类型>(参数表) {}
+template<>char * Max<char *>(char *a,char *b) {
+    return (strcmp(a,b)>=0)?a:b;
+}
+int main(){
+    float  c=5.1,d=3.2;
+    cout<<"2,3的最大值是："<<Max(3,2)<<endl;   
+    cout<<"c,d的最大值是："<<Max(c,d)<<endl;   
+    cout<<Max("xbv","xyce")<<endl;         
+    system("pause");
+}
+/*
+① 当程序中同时存在模板和它的特化时，特化将被优先调用；
+② 在同一个程序中，除了函数模板和它的特化外，还可以有同名的普通函数。其区别在于C++会对普通函数的调用实参进行隐式的类型转换，
+但不会对模板函数及特化函数的参数进行任何形式的类型转换。
+
+*/

practical_exercises/10_day_practice/day8/函数模板/求最大值.cpp

@@ -0,0 +1,21 @@
+//Eg9-2.cpp
+#include <iostream>
+using namespace std;
+template <class T>
+T Max(T a,T b) {
+		return (a>b)?a:b;
+}
+/*
+C++在实例化函数模板的过程中，只是简单地将模板参数替换成调用实参的类型，并以此生成模板函数，不会进行参数类型的任何转换。
+*/
+int main(){
+    double a=2,b=3.4;
+    float  c=5.1,d=3.2;
+    //在模板调用时进行参数类型的强制转换
+    cout<<"2, 3.2    的最大值是："<<Max(double(2),3.2)<<endl;
+    cout<<"a, c    的最大值是："<<Max(float(a),c)<<endl;
+    //显示指定函数模板实例化的参数类型
+    cout<<"'a', 3    的最大值是："<<Max<int>('a',3)<<endl;
+    system("pause");
+}
+

practical_exercises/10_day_practice/day8/函数模板/重要.cpp

@@ -0,0 +1,43 @@
+//Eg9-1.cpp
+#include <iostream>
+//注意一点，max与min使用的时候，容易引起冲突，如果写了下面这一行代码，则要改变函数模板名字，否则直接使用std::cout与std::endl
+using namespace std;
+/*
+不要把这里的class与类的声明关键字class混淆在一起，虽然它们由相同的字母组成，但含义是不同的。
+这里的class表示T是一个类型参数，可以是任何数据类型，如int、float、char等，或者用户定义的struct、enum或class等自定义数据类型。
+*/
+template <class T>
+T Min(T a,T b) {
+	return (a<b)?a:b;
+}
+/*
+为了区别类与模板参数中的类型关键字class，标准C++提出?了用typename作为模板参数的类型关键字，同时也支持使用class。
+比如，把min定义的template <class T>写成下面的形式是完全等价的：
+*/
+template <typename T>
+T myMin(T a, T b){
+    return (a<b)?a:b;
+}
+
+/*
+模板实例化发生在调用模板函数时。当编译器遇到程序中对函数模板的调用时，
+它才会根据调用语句中实参的具体类型，确定模板参数的数据类型，
+并用此类型替换函数模板中的模板参数，生成能够处理该类型的函数代码，即模板函数。
+当多次发生类型相同的参数调用时，只在第1次进行实例化。编译器只在第1次调用时生成模板函数，
+当之后遇到相同类型的参数调用时，不再生成其他模板函数，它将调用第1次实例化生成的模板函数。
+*/
+int main(){
+    double a=2,b=3.4;
+    float  c=2.3,d=3.2;
+    cout<<"2，3    的最小值是："<<Min<int>(2,3)<<endl; //显式调用
+    cout<<"2，3.4  的最小值是："<<Min(a,b)<<endl;//隐式调用
+    cout<<"'a'，'b'	  的最小值是："<<Min('a','b')<<endl;
+    cout<<"2.3，3.2的最小值是："<<Min(c,d)<<endl;
+    cout<<"2.3，3.2的最大值是："<<std::min(c,d)<<endl;//引用命名空间内部的最小值函数
+    cout<<"2.3，3.2的最小值是："<<myMin(c,d)<<endl;//更换class为typename
+    // cout<<"2，'a'    的最小值是："<<Min(2,'a')<<endl; //报错,不同类型无法处理，请看9-3-1.cpp
+    system("pause");
+    return 0;
+}
+
+

practical_exercises/10_day_practice/day8/类模板/模拟栈.cpp

@@ -0,0 +1,78 @@
+/*
+设计一个堆栈的类模板Stack，在模板中用类型参数T表示栈中存放的数据，用非类型参数MAXSIZE代表栈的大小。
+*/
+#include<iostream>
+using namespace std;
+
+template<class T, int MAXSIZE>
+class Stack{
+    private:
+        T elem[MAXSIZE];
+        int top;
+    public:
+        Stack(){top=0;};
+        void push(T e);
+        T pop();
+        bool empty(){
+            if (top<=-1)
+                return 1;
+            else
+                return 0;
+        }
+        void setEmpty(){
+            top=-1;
+        }
+        bool full(){
+            if (top>=MAXSIZE-1)
+            {
+                return 1;
+            }
+            else
+                return 0;
+        }
+};
+/*
+原型：
+template <模板参数列表> 
+返回值类型 类模板名<模板参数名表>::成员函数名 (参数列表){};
+*/
+template<class T, int MAXSIZE>
+void Stack<T,MAXSIZE>::push(T e){
+    if(full()){
+        cout<<"栈已满，不能再添加元素了！";
+        return;
+    }
+    elem[++top]=e;
+}
+
+template<class T, int MAXSIZE>
+T Stack<T,MAXSIZE>::pop(){
+    if(empty()){
+        cout<<"栈已空，不能再弹出元素了！"<<endl;
+        return 0;
+    }
+	return elem[top--];
+}
+
+
+int main(int argc, char const *argv[])
+{
+    //类模板实例化
+    Stack<int,10>  iStack;      	
+    Stack<char,10>  cStack; 
+    iStack.setEmpty(); 
+    cStack.setEmpty();    	
+    cout<<"-------intStack----\n";
+    int i;
+    for(i=1;i<11;i++) 
+        iStack.push(i);
+    for(i=1;i<11;i++) cout<<iStack.pop()<<"\t";
+    cout<<"\n\n-------charStack----\n";
+    cStack.push('A');	cStack.push('B');
+    cStack.push('C'); 	cStack.push('D');
+    cStack.push('E');
+    for(i=1;i<6;i++)  cout<<cStack.pop()<<"\t";
+    cout<<endl;
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day8/类模板/类模板特化.cpp

@@ -0,0 +1,72 @@
+//设计一通用数组类，它能够直接存取数组元素，并能够对数组进行从大到小的排序。
+
+#include<iostream>
+#include<cstring>
+using namespace std;
+const int Size=5;
+template<class T>
+class Array{
+    private:
+        T a[Size];
+    public:
+        Array(){
+            for(int i=0;i<Size;i++){
+                a[i]=0;
+            }
+        }
+        T &operator[](int i);
+        void Sort();
+};
+
+template<class T> T& Array<T>::operator[](int i){
+    if(i<0||i>Size-1){
+        cout<<"\n数组下标越界！"<<endl;
+        exit(1);
+    }
+    return a[i];
+}
+
+template<class T> void Array<T>::Sort(){
+    int p;
+    for(int i=0;i<Size-1;i++){
+        p=i;
+        for(int j=i;j<Size;j++){
+            if(a[p]<a[j])
+                p=j;
+        }
+        T t=a[p];
+        a[p]=a[i];
+        a[i]=t;
+    }
+}
+//template <> 返回类型 类模板名<特化的数据类型>::特化成员函数名(参数表){}
+template<> void Array<char *>::Sort(){
+    int p;
+    for(int i=0;i<Size-1;i++){
+        p=i;
+        for(int j=i+1;j<Size;j++)
+            if(strcmp(a[p],a[j])<0)
+                p=j;
+        char* t=a[p];
+        a[p]=a[i];
+        a[i]=t;
+    }
+}
+
+int main(){
+    Array<int> a1;
+    Array<char*>b1;
+    a1[0]=1;a1[1]=23;a1[2]=6;
+    a1[3]=3; a1[4]=9; 	
+    a1.Sort();
+    for(int i=0;i<5;i++) 
+    cout<<a1[i]<<"\t";
+    cout<<endl;	
+    b1[0]="x1";	b1[1]="ya";	b1[2]="ad";
+    b1[3]="be";	b1[4]="bc";	
+    b1.Sort();
+    for(int i=0;i<5;i++)
+    cout<<b1[i]<<"\t";
+    cout<<endl;	
+    system("pause");
+}

practical_exercises/10_day_practice/day9/readme.md

@@ -0,0 +1,26 @@
+# 异常处理
+1.catch捕获异常时，不会进行数据类型的默认转换。
+2.限制异常的方法
+- 当一个函数声明中不带任何异常描述时，它可以抛出任何异常。例如：
+```c++
+int f(int,char);                 //函数f可以抛出任何异常
+```
+- 在函数声明的后面添加一个throw参数表，在其中指定函数可以抛出的异常类型。例如：
+```c++
+int g(int,char)  throw(int,char);  //只允许抛出int和char异常。
+```
+- 指定throw限制表为不包括任何类型的空表，不允许函数抛出任何异常。如：
+```c++
+int h(int,char) throw();//不允许抛出任何异常
+```
+3.捕获所有异常
+在多数情况下，catch都只用于捕获某种特定类型的异常，但它也具有捕获全部异常的能力。其形式如下：
+```c++
+catch(…) {
+    ……                        //异常处理代码
+}
+```
+4.再次抛出异常
+如是catch块无法处理捕获的异常，它可以将该异常再次抛出，使异常能够在恰当的地方被处理。再次抛出的异常不会再被同一个catch块所捕获，它将被传递给外部的catch块处理。要在catch块中再次抛出同一异常，只需在该catch块中添加不带任何参数的throw语句即可。
+5.异常的嵌套调用
+try块可以嵌套，即一个try块中可以包括另一个try块，这种嵌套可能形成一个异常处理的调用链。

practical_exercises/10_day_practice/day9/异常例子/1.cpp

@@ -0,0 +1,19 @@
+//Eg10-1.cpp
+#include<iostream>
+using namespace std;
+int main(){
+    cout<<"1--befroe try block..."<<endl;
+    try{
+        cout<<"2--Inside try block..."<<endl;
+        throw 10;
+        cout<<"3--After throw ...."<<endl;
+    }
+    catch(int i) {
+	    cout<<"4--In catch block1 ... exception..errcode  is.."<<i<<endl;
+    }
+    catch(char * s) {
+        cout<<"5--In catch block2 ... exception..errcode is.."<<s<<endl;
+    }
+    cout<<"6--After Catch...";
+    system("pause");
+}

practical_exercises/10_day_practice/day9/异常例子/10.cpp

@@ -0,0 +1,42 @@
+//Eg10-11.cpp
+#include <iostream>
+using namespace std;
+const int MAX=3;
+class Full{
+    int a;
+    public:
+        Full(int i):a(i){}
+        int getValue(){return a;}
+};
+class Empty{};
+class Stack{
+    private:
+        int s[MAX];
+        int top;
+    public:
+        Stack(){top=-1;}
+        void push(int a){
+            if(top>=MAX-1)  
+                throw Full(a);			
+            s[++top]=a;
+        }
+        int pop(){
+            if(top<0)
+                throw Empty();
+            return s[top--];
+        }
+};
+int main(){
+    Stack s;
+    try{
+        s.push(10);  
+        s.push(20);
+        s.push(30);  
+        s.push(40);
+    }
+    catch(Full e){	
+        cout<<"Exception: Stack Full..."<<endl;
+        cout<<"The value not push in stack:"<<e.getValue()<<endl; 
+    }
+    system("pause");
+}

practical_exercises/10_day_practice/day9/异常例子/2.cpp

@@ -0,0 +1,17 @@
+//Eg10-2.cpp
+#include<iostream>
+using namespace std;
+int main(){
+    cout<<"1--befroe try block..."<<endl;
+    try{
+        cout<<"2--Inside try block..."<<endl;
+        throw 10;                        
+        cout<<"3--After throw ...."<<endl;
+    }
+    catch(double i) { 		//仅此与例10.1不同
+        cout<<"4--In catch block1 .. an int type is.."<<i<<endl;
+    }
+    cout<<"5--After Catch...";
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day9/异常例子/3.cpp

@@ -0,0 +1,19 @@
+#include<iostream>
+using namespace std;
+void temperature(int t)
+{
+    try{
+        if(t==100) throw "沸点！";
+        else if(t==0) throw "冰点！";
+        else cout<<"the temperature is OK..."<<endl;
+    }
+    catch(int x){cout<<"temperatore="<<x<<endl;}
+    catch(char const*s){cout<<s<<endl;}
+}
+int main(){
+    temperature(0);						//L1
+    temperature(10);						//L2
+    temperature(100);						//L3
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day9/异常例子/4.cpp

@@ -0,0 +1,20 @@
+#include<iostream>
+using namespace std;
+void temperature(int t)
+{
+    
+    if(t==100) throw "沸点！";
+    else if(t==0) throw "冰点！";
+    else{cout<<"temperatore="<<t<<endl;}
+   
+}
+int main(){
+    try{
+        temperature(0);						//L1
+        temperature(10);						//L2
+        temperature(100);						//L3
+    }
+    catch(char const*s){cout<<s<<endl;}
+    system("pause");
+    return 0;
+}

practical_exercises/10_day_practice/day9/异常例子/5.cpp

@@ -0,0 +1,19 @@
+//Eg10-5.cpp
+#include<iostream>
+using namespace std;
+
+void handler(int n)throw(int,char,double){
+    if(n==1) throw n;
+    if(n==2) throw 'x';
+    if(n==3) throw 1.1;
+}
+int main(){
+    cout<<"Before handler..."<<endl;
+    try{
+        handler(1);
+    }
+    catch(int i){ cout<<"catch an integer..."<<endl;}
+    catch(char c){cout<<"catch an char..."<<endl;}
+    catch(double d){cout<<"catch an double..."<<endl;}
+    system("pause");
+}

practical_exercises/10_day_practice/day9/异常例子/6.cpp

@@ -0,0 +1,18 @@
+//Eg10-6.cpp
+#include<iostream>
+using namespace std;
+void Errhandler(int n)throw(){
+    try{
+        if(n==1) throw n;
+        if(n==2) throw "dx";
+        if(n==3) throw 1.1;
+    }
+    catch(...){cout<<"catch an exception..."<<endl;}
+}
+int main(){
+    Errhandler(1);
+    Errhandler(2);
+    Errhandler(3);
+    system("pause");
+    return 0;
+} 

practical_exercises/10_day_practice/day9/异常例子/7-1.cpp

@@ -0,0 +1,33 @@
+//Eg10-9.cpp
+#include<iostream>
+using namespace std;
+class A{
+    int a;
+public:
+    A(int i=0):a(i){}
+    ~A(){cout<<"in A destructor..."<<endl;}
+};
+class B{
+    A obj[3];
+    double *pb[10];
+    public:
+        B(int k){
+            cout<<"int B constructor..."<<endl;
+            for (int i=0;i<10;i++){
+                pb[i]=new double[20000000];
+                if(pb[i]==0)
+                    throw i;
+                else 
+                    cout<<"Allocated 20000000 doubles in pb["<<i<<"]"<<endl;
+            }
+        }
+};
+int main(){
+    try{
+        B b(2);
+    }
+    catch(int e){
+        cout<<"catch an exception when allocated pb["<<e<<"]"<<endl;   
+    }
+    system("pause");
+}

practical_exercises/10_day_practice/day9/异常例子/7.cpp

@@ -0,0 +1,24 @@
+//Eg10-7.cpp
+#include<iostream>
+using namespace std;
+//内部再次throw异常的时候，函数不要带throw()
+void Errhandler(int n)
+{
+    try{
+        if(n==1) throw n;
+        cout<<"all is ok..."<<endl;
+    }
+    catch(int n){
+        cout<<"catch an int exception inside..."<<n<<endl;
+        throw n;                                     //再次抛出本catch捕获的异常
+    }
+}
+int main(){
+    try{
+        Errhandler(1); 
+    }
+    catch(int x){ cout<<"catch int an exception in main..."<<x<<endl; }
+    cout<<"....End..."<<endl;
+    system("pause");
+    return 0;
+}