feat: 统一 cpp 文件编码格式为 utf-8

practical_exercises/10_day_practice/day1/注释.cpp

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

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

@@ -1,6 +1,6 @@
 #include<iostream>
 using namespace std;
-//相同的内存地址
+//相同的内存地址
 union myun 
 {
     struct { int x; int y; int z; }u; 
@@ -11,7 +11,7 @@ int main()
     a.u.x =4;
     a.u.y =5; 
     a.u.z =6; 
-    a.k = 0; //覆盖掉第一个int空间值
+    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/文件例题/12-1.cpp

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

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

@@ -1,6 +1,6 @@
 #include<iostream>
 using namespace std;
-//函数原型
+//函数原型
 //put(char c)
 //write(const char*c, int n)
 int main(){

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

@@ -7,11 +7,11 @@ int main(){
     double d=-1234.8976;
     cout<<setw(30)<<left<<setfill('*')<<c<<"----L1"<<endl;
     cout<<setw(30)<<right<<setfill('*')<<c<<"----L2"<<endl;
-    //showbase显示数值的基数前缀
+    //showbase显示数值的基数前缀
     cout<<dec<<showbase<<showpoint<<setw(30)<<d<<"----L3"<<"\n";
-    //showpoint显示小数点
+    //showpoint显示小数点
     cout<<setw(30)<<showpoint<<setprecision(10)<<d<<"----L4"<<"\n";
-    //setbase(8)设置八进制
+    //setbase(8)设置八进制
     cout<<setw(30)<<setbase(16)<<100<<"----L5"<<"\n";
     system("pause");
 }

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

@@ -6,16 +6,16 @@ int main(int argc, char const *argv[])
 {
     fstream ioFile;
     ioFile.open("./a.dat",ios::out);
-    ioFile<<"张三"<<"  "<<76<<" "<<98<<" "<<67<<endl;	//L3
+    ioFile<<"张三"<<"  "<<76<<" "<<98<<" "<<67<<endl;	//L3
-    ioFile<<"李四"<<"  "<<89<<" "<<70<<" "<<60<<endl;
+    ioFile<<"李四"<<"  "<<89<<" "<<70<<" "<<60<<endl;
-    ioFile<<"王十"<<"  "<<91<<" "<<88<<" "<<77<<endl;
+    ioFile<<"王十"<<"  "<<91<<" "<<88<<" "<<77<<endl;
-    ioFile<<"黄二"<<"  "<<62<<" "<<81<<" "<<75<<endl;
+    ioFile<<"黄二"<<"  "<<62<<" "<<81<<" "<<75<<endl;
-    ioFile<<"刘六"<<"  "<<90<<" "<<78<<" "<<67<<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; 
+    cout<<"姓名\t"<<"英语\t"<<"数学\t"<<"计算机\t"<<"总分"<<endl; 
     ioFile>>name;										
     while(!ioFile.eof())	{								
         ioFile>>chinese>>math>>computer;					

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

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

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

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

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

@@ -1,6 +1,6 @@
 #include<iostream>
 #include<fstream>
-//向量是一个能够存放任意类型的动态数组
+//向量是一个能够存放任意类型的动态数组
 #include<vector>
 #include<cstring>
 using namespace std;
@@ -25,20 +25,20 @@ class Person{
 int main(int argc, char const *argv[])
 {
     vector<Person> v;
-    vector<Person>::iterator pos;//声明一个迭代器，来访问vector容器，作用：遍历或者指向vector容器的元素 
+    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;
+    cout<<"------输入个人档案------"<<endl<<endl;
     do{
-        cout<<"姓名： ";
+        cout<<"姓名： ";
         cin>>Name;
-        cout<<"身份证号： ";
+        cout<<"身份证号： ";
         cin>>ID;
-        cout<<"年龄： ";
+        cout<<"年龄： ";
         cin>>Age;
-        cout<<"地址： ";
+        cout<<"地址： ";
         cin>>Addr;
         Person per(Name,ID,Age,Addr);
         out.write((char*)&per,sizeof(per));
@@ -53,7 +53,7 @@ int main(int argc, char const *argv[])
         v.push_back(s);						       
         in.read((char*)&s,sizeof(s));			
     }								 
-    cout<<"\n---------从文件中读出的数据--------"<<endl<<endl;//L15
+    cout<<"\n---------从文件中读出的数据--------"<<endl<<endl;//L15
     pos=v.begin();						
     for(pos=v.begin();pos!=v.end();pos++)				        
         (*pos).display();				

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

@@ -6,7 +6,7 @@ int main(int argc, char const *argv[])
 {
     int flag;
     unsigned seed;
-    cout<<"请输入无符号整数："<<endl;
+    cout<<"请输入无符号整数："<<endl;
     cin>>seed;
     srand(seed);
     int sum = rolldice();

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

@@ -14,7 +14,7 @@ int main(int argc, char const *argv[])
     {
         cout<<i<<endl;
         cout<<wek+s<<endl;
-        cout<<"-------¹þ¹þ-------"<<endl;
+        cout<<"-------哈哈-------"<<endl;
     }
     system("pause");
     return 0;

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

@@ -4,7 +4,7 @@ void move(char A, char B);
 void hanoi(int n,char A, char B, char C);
 int main(int argc, char const *argv[])
 {
-    cout<<"请输入盘子数量：";
+    cout<<"请输入盘子数量：";
     int disks;
     cin>>disks;
     hanoi(disks,'A','B','C');

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

@@ -3,7 +3,7 @@ using namespace std;
 int f(int n, int k);
 int main(int argc, char const *argv[])
 {
-    cout<<"ÇëÊäÈënÓëk"<<endl;
+    cout<<"请输入n与k"<<endl;
     int n,k;
     cin>>n;
     cin>>k;

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

@@ -1,10 +1,10 @@
 #include<iostream>
 using namespace std;
-int i=1;  // i 为全局变量，具有静态生存期。
+int i=1;  // i 为全局变量，具有静态生存期。
 int main(void)   
 { 
-    static int a;  // 静态局部变量，有全局寿命，局部可见。
+    static int a;  // 静态局部变量，有全局寿命，局部可见。
-    int b=-10;  // b, c为局部变量，具有动态生存期。
+    int b=-10;  // b, c为局部变量，具有动态生存期。
     int c=0;
     void other(void);
     cout<<"---MAIN---\n";
@@ -21,10 +21,10 @@ void other(void)
 {
     static int a=2;
     static int b;
-    // a,b为静态局部变量，具有全局寿命，局部可见。
+    // a,b为静态局部变量，具有全局寿命，局部可见。
-    //只第一次进入函数时被初始化。
+    //只第一次进入函数时被初始化。
-    int c=10;   // C为局部变量，具有动态生存期
+    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;

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

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

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

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

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

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

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

@@ -1,8 +1,8 @@
 /*
-知识点：
+知识点：
-静态成员函数
+静态成员函数
-类外代码可以使用类名和作用域操作符来调用静态成员函数。
+类外代码可以使用类名和作用域操作符来调用静态成员函数。
-静态成员函数只能引用属于该类的静态数据成员或静态成员函数。
+静态成员函数只能引用属于该类的静态数据成员或静态成员函数。
 */
 #include<iostream>
 using namespace std;

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

@@ -10,9 +10,9 @@ class A
 void A::f(A a)
 {
    
-    //静态成员函数只能引用属于该类的静态数据成员或静态成员函数。
+    //静态成员函数只能引用属于该类的静态数据成员或静态成员函数。
-    // cout<<x; //对x的引用是错误的
+    // cout<<x; //对x的引用是错误的
-    cout<<a.x;  //正确
+    cout<<a.x;  //正确
 }
 
 int main(int argc, char const *argv[])

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

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

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

@@ -13,12 +13,12 @@ class A
 int main()
 {   double d(9.5);
      display(d);
-     A const a(3,4); //a是常对象，不能被更新
+     A const a(3,4); //a是常对象，不能被更新
      system("pause");
      return 0;
 }
 void display(const double& r)
-//常引用做形参，在函数中不能更新 r所引用的对象。
+//常引用做形参，在函数中不能更新 r所引用的对象。
 {   cout<<r<<endl;   }
 
 

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

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

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

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

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

@@ -1,13 +1,13 @@
 #include<iostream>
 using namespace std;
 /*
-若一个类为另一个类的友元，则此类的所有成员都能访问对方类的私有成员。
+若一个类为另一个类的友元，则此类的所有成员都能访问对方类的私有成员。
-声明语法：将友元类名在另一个类中使用friend修饰说明。
+声明语法：将友元类名在另一个类中使用friend修饰说明。
 */
 
 /*
-如果声明B类是A类的友元，B类的成员函数就可以访问A类的私有和保护数据，
+如果声明B类是A类的友元，B类的成员函数就可以访问A类的私有和保护数据，
-但A类的成员函数却不能访问B类的私有、保护数据。
+但A类的成员函数却不能访问B类的私有、保护数据。
 */
 class A{
   friend class B;
@@ -45,5 +45,5 @@ int main(int argc, char const *argv[])
 }
 
 /*
-如果声明B类是A类的友元，B类的成员函数就可以访问A类的私有和保护数据，但A类的成员函数却不能访问B类的私有、保护数据
+如果声明B类是A类的友元，B类的成员函数就可以访问A类的私有和保护数据，但A类的成员函数却不能访问B类的私有、保护数据
 */

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

@@ -15,7 +15,7 @@ Clock::Clock(Clock &c)
 }
 void Clock::SetTime(int NewH,int NewM,int NewS)
 {
-    //加不加this指针都一样
+    //加不加this指针都一样
     this->Hour=NewH;
     this->Minute=NewM;
     this->Second=NewS;
@@ -26,7 +26,7 @@ void Clock::ShowTime()
     cout<<this->Minute<<endl;
     cout<<this->Second<<endl;
 }
-//析构函数
+//析构函数
 Clock::~Clock()
 {
 
@@ -37,7 +37,7 @@ int main(int argc, char const *argv[])
     
     c.SetTime(10,20,30);
     c.ShowTime();
-    //拷贝构造函数调用
+    //拷贝构造函数调用
     Clock c1(c);
     c1.ShowTime();
     c1.SetTime(90,98,99);

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

@@ -24,19 +24,19 @@ int main(){
     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;		

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

@@ -2,8 +2,8 @@
 using namespace std;
 
 /*
-先构造成员
+先构造成员
-再构造自身（调用构造函数）
+再构造自身（调用构造函数）
 */
 
 class A { 
@@ -33,7 +33,7 @@ int main()
 }
 
 /*
-执行结果：
+执行结果：
 Constructing B
 Constructing A
 Constructing C

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

@@ -14,7 +14,7 @@ class Derived:public  Base{
 private:
     int y;
 public:
-    Derived(int a,int b):Base(a){       //派生类构造函数的初始化列表
+    Derived(int a,int b):Base(a){       //派生类构造函数的初始化列表
         y=b;
         cout<<"Derived constructor y="<<y<<endl;
     }

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

@@ -32,7 +32,7 @@ int main()
 }
 
 /*
-执行结果：
+执行结果：
 Constructing C
 Constructing B
 Constructing A

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

@@ -13,7 +13,7 @@ class Line:public Point{
 protected:
     int len;
 public:
-    Line(int a,int b,int l):Point(a,b) {	//构造函数初始化列表
+    Line(int a,int b,int l):Point(a,b) {	//构造函数初始化列表
         len=l;
         cout<<"Constructing Line,len ..."<<len<<endl;
     }

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

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

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

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

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

@@ -7,7 +7,7 @@ public:
 	int getx(){	return x;  }
 	void showx()	{	cout<<x<<endl;  }
 };
-//派生类
+//派生类
 class derived:public base{
 	int y;
 public:
@@ -16,7 +16,7 @@ public:
 	void showy()
 	{	cout<<y<<endl;   }
 };
-//派生类不可直接访问基类的private成员，可通过基类的共有成员函数访问
+//派生类不可直接访问基类的private成员，可通过基类的共有成员函数访问
 int main()
 {	derived obj;
 	obj.setx(10);	

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

@@ -22,8 +22,8 @@ public:
 };
 class ABC:public C, public B {
 public: 
-    //虚基类由最终派生类初始化 
+    //虚基类由最终派生类初始化 
-    ABC(int i,int j,int k):C(i),B(j),A(i) //L1，这里必须对A进行初始化
+    ABC(int i,int j,int k):C(i),B(j),A(i) //L1，这里必须对A进行初始化
         { cout<<"Constructing ABC..."<<endl; }
 }; 
 int main(){

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

@@ -1,4 +1,4 @@
-//重要!!!
+//重要!!!
 #include <iostream>
 using namespace std;
 class A {

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

@@ -1,4 +1,4 @@
-//当同时存在直接基类和间接基类时，每个派生类只负责其直接基类的构造。
+//当同时存在直接基类和间接基类时，每个派生类只负责其直接基类的构造。
 #include <iostream>
 using namespace std;
 class A { 

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

@@ -13,21 +13,21 @@ class Figure{
 class Trianle:public Figure{
     public:
         void area(){
-            cout<<"三角形面积："<<x*y*0.5<<endl;
+            cout<<"三角形面积："<<x*y*0.5<<endl;
         }
 };
 class Rectangle:public Figure{
     public:
         void area(){
-            cout<<"这是矩形，它的面积是："<<x*y<<endl;
+            cout<<"这是矩形，它的面积是："<<x*y<<endl;
         }
 };
 
 int main(int argc, char const *argv[])
 {
-    //定义抽象类指针
+    //定义抽象类指针
     Figure *pF=NULL;
-    // Figure f1; 抽象类不能被实例化
+    // Figure f1; 抽象类不能被实例化
     Rectangle r;
     Trianle t;
     t.set(10,20);
@@ -36,7 +36,7 @@ int main(int argc, char const *argv[])
     r.set(10,20);
     pF=&r;
     pF->area();
-    //定义抽象类引用
+    //定义抽象类引用
     Figure &rF=t;
     rF.set(20,20);
     rF.area();

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

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

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

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

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

@@ -1,4 +1,4 @@
-//例题ch.cppi
+//例题ch.cppi
 #include <iostream>
 using namespace std;
 class X{
@@ -9,8 +9,8 @@ public:
 int main ()
 {
 	X obj1, obj2, obj3;
-	obj1 = obj2;          //调用重载“=”
+	obj1 = obj2;          //调用重载“=”
-	obj1.operator= (obj2); //调用重载“=”
+	obj1.operator= (obj2); //调用重载“=”
-	obj1 = obj2 = obj3;    //调用重载“=”
+	obj1 = obj2 = obj3;    //调用重载“=”
     system("pause");
 }

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

@@ -2,27 +2,27 @@
 #include <iostream>
 #include <cstring>
 using namespace std;
-struct Person{                		//职工基本信息的结构
+struct Person{                		//职工基本信息的结构
 		double salary;
 		char *name;
 };
 class SalaryManaege{
-		Person *employ;          	 //存放职工信息的数组
+		Person *employ;          	 //存放职工信息的数组
-		int max;                  		//数组下标上界
+		int max;                  		//数组下标上界
-		int n;                    		//数组中的实际职工人数
+		int n;                    		//数组中的实际职工人数
 public:
 	SalaryManaege(int Max=0){
 		max=Max;
 		n=0;
 		employ=new Person[max];
 	}
-    double &operator[](char *Name) {       	//重载[]，返回引用
+    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);
@@ -37,13 +37,13 @@ public:
 };
 int main(){
     SalaryManaege s(3);
-    s["张三"]=2188.88;
+    s["张三"]=2188.88;
-    s["里斯"]=1230.07;
+    s["里斯"]=1230.07;
-    s["王无"]=3200.97;
+    s["王无"]=3200.97;
-    cout<<"张三\t"<<s["张三"]<<endl;          cout<<"里斯\t"<<s["里斯"]<<endl;
+    cout<<"张三\t"<<s["张三"]<<endl;          cout<<"里斯\t"<<s["里斯"]<<endl;
-    cout<<"王无\t"<<s["王无"]<<endl;
+    cout<<"王无\t"<<s["王无"]<<endl;
   
-    cout<<"-------下为display的输出--------\n\n";
+    cout<<"-------下为display的输出--------\n\n";
     s.display();
     system("pause");
 }

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

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

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

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

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

@@ -6,21 +6,21 @@ template <class T>
 T Max(T a,T b) {
     return (a>b)?a:b;
 }
-//特化
+//特化
-//template <> 返回类型 函数名<特化的数据类型>(参数表) {}
+//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<<"2,3的最大值是："<<Max(3,2)<<endl;   
-    cout<<"c,d的最大值是："<<Max(c,d)<<endl;   
+    cout<<"c,d的最大值是："<<Max(c,d)<<endl;   
     cout<<Max("xbv","xyce")<<endl;         
     system("pause");
 }
 /*
-① 当程序中同时存在模板和它的特化时，特化将被优先调用；
+① 当程序中同时存在模板和它的特化时，特化将被优先调用；
-② 在同一个程序中，除了函数模板和它的特化外，还可以有同名的普通函数。其区别在于C++会对普通函数的调用实参进行隐式的类型转换，
+② 在同一个程序中，除了函数模板和它的特化外，还可以有同名的普通函数。其区别在于C++会对普通函数的调用实参进行隐式的类型转换，
-但不会对模板函数及特化函数的参数进行任何形式的类型转换。
+但不会对模板函数及特化函数的参数进行任何形式的类型转换。
 
 */

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

@@ -6,16 +6,16 @@ T Max(T a,T b) {
 		return (a>b)?a:b;
 }
 /*
-C++在实例化函数模板的过程中，只是简单地将模板参数替换成调用实参的类型，并以此生成模板函数，不会进行参数类型的任何转换。
+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<<"2, 3.2    的最大值是："<<Max(double(2),3.2)<<endl;
-    cout<<"a, c    的最大值是："<<Max(float(a),c)<<endl;
+    cout<<"a, c    的最大值是："<<Max(float(a),c)<<endl;
-    //显示指定函数模板实例化的参数类型
+    //显示指定函数模板实例化的参数类型
-    cout<<"'a', 3    的最大值是："<<Max<int>('a',3)<<endl;
+    cout<<"'a', 3    的最大值是："<<Max<int>('a',3)<<endl;
     system("pause");
 }
 

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

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

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

@@ -1,5 +1,5 @@
 /*
-设计一个堆栈的类模板Stack，在模板中用类型参数T表示栈中存放的数据，用非类型参数MAXSIZE代表栈的大小。
+设计一个堆栈的类模板Stack，在模板中用类型参数T表示栈中存放的数据，用非类型参数MAXSIZE代表栈的大小。
 */
 #include<iostream>
 using namespace std;
@@ -32,14 +32,14 @@ class Stack{
         }
 };
 /*
-原型：
+原型：
-template <模板参数列表> 
+template <模板参数列表> 
-返回值类型 类模板名<模板参数名表>::成员函数名 (参数列表){};
+返回值类型 类模板名<模板参数名表>::成员函数名 (参数列表){};
 */
 template<class T, int MAXSIZE>
 void Stack<T,MAXSIZE>::push(T e){
     if(full()){
-        cout<<"栈已满，不能再添加元素了！";
+        cout<<"栈已满，不能再添加元素了！";
         return;
     }
     elem[++top]=e;
@@ -48,7 +48,7 @@ void Stack<T,MAXSIZE>::push(T e){
 template<class T, int MAXSIZE>
 T Stack<T,MAXSIZE>::pop(){
     if(empty()){
-        cout<<"栈已空，不能再弹出元素了！"<<endl;
+        cout<<"栈已空，不能再弹出元素了！"<<endl;
         return 0;
     }
 	return elem[top--];
@@ -57,7 +57,7 @@ T Stack<T,MAXSIZE>::pop(){
 
 int main(int argc, char const *argv[])
 {
-    //类模板实例化
+    //类模板实例化
     Stack<int,10>  iStack;      	
     Stack<char,10>  cStack; 
     iStack.setEmpty(); 

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

@@ -1,4 +1,4 @@
-//设计一通用数组类，它能够直接存取数组元素，并能够对数组进行从大到小的排序。
+//设计一通用数组类，它能够直接存取数组元素，并能够对数组进行从大到小的排序。
 
 #include<iostream>
 #include<cstring>
@@ -20,7 +20,7 @@ class Array{
 
 template<class T> T& Array<T>::operator[](int i){
     if(i<0||i>Size-1){
-        cout<<"\n数组下标越界！"<<endl;
+        cout<<"\n数组下标越界！"<<endl;
         exit(1);
     }
     return a[i];
@@ -39,7 +39,7 @@ template<class T> void Array<T>::Sort(){
         a[i]=t;
     }
 }
-//template <> 返回类型 类模板名<特化的数据类型>::特化成员函数名(参数表){}
+//template <> 返回类型 类模板名<特化的数据类型>::特化成员函数名(参数表){}
 template<> void Array<char *>::Sort(){
     int p;
     for(int i=0;i<Size-1;i++){

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

@@ -8,7 +8,7 @@ int main(){
         throw 10;                        
         cout<<"3--After throw ...."<<endl;
     }
-    catch(double i) { 		//仅此与例10.1不同
+    catch(double i) { 		//仅此与例10.1不同
         cout<<"4--In catch block1 .. an int type is.."<<i<<endl;
     }
     cout<<"5--After Catch...";

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

@@ -3,8 +3,8 @@ using namespace std;
 void temperature(int t)
 {
     
-    if(t==100) throw "沸点！";
+    if(t==100) throw "沸点！";
-    else if(t==0) throw "冰点！";
+    else if(t==0) throw "冰点！";
     else{cout<<"temperatore="<<t<<endl;}
    
 }

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

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

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

@@ -2,8 +2,8 @@
 #include <iostream>
 using namespace std;
 const int MAX=3;
-class Full{};	//L1  堆栈满时抛出的异常类
+class Full{};	//L1  堆栈满时抛出的异常类
-class Empty{};	//L2  堆栈空时抛出的异常类
+class Empty{};	//L2  堆栈空时抛出的异常类
 class Stack{
     private:
         int s[MAX];
@@ -26,7 +26,7 @@ int main(){
     Stack s;
     try{
         s.push(10);        s.push(20);        s.push(30);
-        //s.push(40);	//L5  将产生栈满异常
+        //s.push(40);	//L5  将产生栈满异常
         cout<<"stack(0)= "<<s.pop()<<endl;
         cout<<"stack(1)= "<<s.pop()<<endl;
         cout<<"stack(2)= "<<s.pop()<<endl;

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

@@ -19,7 +19,7 @@ class DiskNotFound:public FileSysException{
 };
 int main(){
     try{
-//         .....  //程序代码
+//         .....  //程序代码
          throw FileSysException();
     }
     catch(DiskNotFound p){cout<<p.Where()<<endl;}
@@ -27,7 +27,7 @@ int main(){
     catch(FileSysException p){cout<<p.Where()<<endl;}
     catch(BasicException p){cout<<p.Where()<<endl;}
     try{
-//        .....  //程序代码
+//        .....  //程序代码
          throw DiskNotFound();
     }
     catch(BasicException p){cout<<p.Where()<<endl;}

practical_exercises/key_exercises/字典插入与查找.cpp

@@ -12,64 +12,64 @@ int main(int argc, char const *argv[])
     const char key[3][20]={"img","system","ip"};
     const char value[3][20]={"d:/a.img","win7","193.68.6.3"};
     
-    //make_pair插入
+    //make_pair插入
     for(int i=0;i<2;i++){
         mp.insert(make_pair(key[i],value[i]));
     }
-    //pair<const char*,const char*>插入
+    //pair<const char*,const char*>插入
     mp.insert(pair<const char*,const char*>(key[2],value[2]));
 
-    //数组插入方式
+    //数组插入方式
-    mp["addr"]="中国";
+    mp["addr"]="中国";
-    //迭代器取出元素
+    //迭代器取出元素
-    //循环取出元素
+    //循环取出元素
     for(iter=mp.begin();iter!=mp.end();iter++){
         cout<<iter->first<<"\t"<<iter->second<<endl;
     }
     char key1[20];
-    cout<<"请输入按key查找：";
+    cout<<"请输入按key查找：";
     cin.getline(key1,20);
-    //查找元素
+    //查找元素
     for(iter=mp.begin();iter!=mp.end();iter++){
         if(strcmp(iter->first,key1)==0){
-            cout<<iter->first<<"查找出来了！"<<"对应的值为："<<iter->second<<endl;
+            cout<<iter->first<<"查找出来了！"<<"对应的值为："<<iter->second<<endl;
         }
     }
    
-    //第一种删除方式
+    //第一种删除方式
-    //find只能用于查找数组建立的形式！并且不支持输入用cin等
+    //find只能用于查找数组建立的形式！并且不支持输入用cin等
     iter=mp.find("addr");
     if(iter!=mp.end()){
-        cout<<iter->first<<"按照key查找出来了！"<<"对应的value为："<<iter->second<<endl;
+        cout<<iter->first<<"按照key查找出来了！"<<"对应的value为："<<iter->second<<endl;
-        cout<<"开始删除元素！"<<endl;
+        cout<<"开始删除元素！"<<endl;
         mp.erase(iter);
         // break;
     }
-    //第二种方式删除
+    //第二种方式删除
-     //按照key删除元素
+     //按照key删除元素
     char drop_key[20];
-    //按照value删除元素
+    //按照value删除元素
     char drop_value[20];
-    cout<<"请输入按key删除：";
+    cout<<"请输入按key删除：";
     cin.getline(drop_key,20);
-    cout<<"请输入按value删除：";
+    cout<<"请输入按value删除：";
     cin.getline(drop_value,20);
     for(iter=mp.begin();iter!=mp.end();iter++){
         if(strcmp(iter->first,drop_key)==0){
-            cout<<iter->first<<"按照key查找出来了！"<<"对应的value为："<<iter->second<<endl;
+            cout<<iter->first<<"按照key查找出来了！"<<"对应的value为："<<iter->second<<endl;
-            cout<<"开始删除元素！"<<endl;
+            cout<<"开始删除元素！"<<endl;
             mp.erase(iter);
             break;
         }
         if(strcmp(iter->second,drop_value)==0){
-            cout<<iter->second<<"value查找出来了！"<<"对应的key为："<<iter->first<<endl;
+            cout<<iter->second<<"value查找出来了！"<<"对应的key为："<<iter->first<<endl;
-            cout<<"开始删除元素！"<<endl;
+            cout<<"开始删除元素！"<<endl;
             mp.erase(iter);
             break;
         }
     }
-    cout<<"------删除元素以后--------\n";
+    cout<<"------删除元素以后--------\n";
-    //循环取出元素
+    //循环取出元素
     for(iter=mp.begin();iter!=mp.end();iter++){
         cout<<iter->first<<"\t"<<iter->second<<endl;
     }

practical_exercises/key_exercises/异常捕获.cpp

@@ -1,10 +1,10 @@
 #include<iostream>
 using namespace std;
-//函数异常可以抛出去由主函数来处理
+//函数异常可以抛出去由主函数来处理
 void fun(int x){
     try{
         if (x==0)
-            throw "异常";
+            throw "异常";
     }catch(...){
         cout<<"in fun"<<endl;
         throw 1;

practical_exercises/key_exercises/时钟++运算符重载.cpp

@@ -3,7 +3,7 @@
 using namespace std;   
   
 /*  
- *  时钟类  
+ *  时钟类  
  */  
 class Clock    
 {   
@@ -17,7 +17,7 @@ public:
 };   
   
 /*  
- *  时钟类构造函数  
+ *  时钟类构造函数  
  */  
 Clock::Clock(int h,int m, int s)   
 {   
@@ -28,11 +28,11 @@ Clock::Clock(int h,int m, int s)
         Second= s;   
     }   
     else  
-        cout<<"输入的时间格式错误!"<<endl;   
+        cout<<"输入的时间格式错误!"<<endl;   
 }   
   
 /*  
- *  显示时间  
+ *  显示时间  
  */  
 void Clock::ShowTime()   
 {   
@@ -40,7 +40,7 @@ void Clock::ShowTime()
 }   
   
 /*  
- *  时间递增一秒（重载前缀++运算符）  
+ *  时间递增一秒（重载前缀++运算符）  
  */  
 Clock& Clock::operator ++()    
 {    
@@ -60,7 +60,7 @@ Clock& Clock::operator ++()
 }   
   
 /*  
- *  时间递增一秒（重载后缀++运算符）  
+ *  时间递增一秒（重载后缀++运算符）  
  */  
 Clock Clock::operator ++(int)   
 {   
@@ -70,24 +70,24 @@ Clock Clock::operator ++(int)
 }   
   
 /*  
- *  主函数  
+ *  主函数  
  */  
 int main()   
 {   
     Clock myClock(23,59,59);   
-    cout<<"初始化显示时间为:\t\t";   
+    cout<<"初始化显示时间为:\t\t";   
     myClock.ShowTime();   
   
-    cout<<"执行myClock++后的时间为:\t";   
+    cout<<"执行myClock++后的时间为:\t";   
   
-    //先执行ShowTime()，输出myClock=23:59:59，   
+    //先执行ShowTime()，输出myClock=23:59:59，   
-    //再执行myClock++，此时myClock=00:00:00   
+    //再执行myClock++，此时myClock=00:00:00   
     (myClock++).ShowTime();   
   
-    cout<<"执行++myClock后的时间为:\t";   
+    cout<<"执行++myClock后的时间为:\t";   
   
-    //先执行++myClock，此时myClock=00:00:01   
+    //先执行++myClock，此时myClock=00:00:01   
-    //再执行ShowTime()，输出myClock=00:00:01   
+    //再执行ShowTime()，输出myClock=00:00:01   
     (++myClock).ShowTime();   
     system("pause");
 }  

practical_exercises/key_exercises/类模板之栈.cpp

@@ -35,7 +35,7 @@ template<typename T,int MAXSIZE> void Stack<T,MAXSIZE>::push(T e){
         elems[++top]=e;
     }
     else{
-        cout<<"栈已满，请不要再加入元素！";
+        cout<<"栈已满，请不要再加入元素！";
         return;
     }
 }
@@ -44,7 +44,7 @@ template<typename T,int MAXSIZE> T Stack<T,MAXSIZE>::pop(){
         return elems[top--];
     }
     else{
-        cout<<"栈已空，请不要再弹出元素！";
+        cout<<"栈已空，请不要再弹出元素！";
         return 0;
     }
 }

practical_exercises/key_exercises/类模板特化之数组.cpp

@@ -21,7 +21,7 @@ class Array{
 
 template<class T> T& Array<T>::operator[](int i){
     if(i<0||i>MAXSIZE-1){
-        cout<<"数组下标越界！"<<endl;
+        cout<<"数组下标越界！"<<endl;
         exit(0);
     }
     return array[i];

practical_exercises/key_exercises/继承与封装.cpp

@@ -26,12 +26,12 @@ class Employee{
 
 class Manager:public Employee{
     public:
-        //直接调用构造方法传递，基类构造方法有参数，派生类必须通过构造方法，在初始化列表中传递参数
+        //直接调用构造方法传递，基类构造方法有参数，派生类必须通过构造方法，在初始化列表中传递参数
         Manager(const char *name,const char *id,int week):Employee(name,id){
             WeeklySalary=week*1000;
         }
         void display(){
-            cout<<"经理："<<getName()<<"\t"<<getId()<<"\t"<<WeeklySalary<<endl;
+            cout<<"经理："<<getName()<<"\t"<<getId()<<"\t"<<WeeklySalary<<endl;
         }
     private:
         int WeeklySalary;
@@ -43,7 +43,7 @@ class SaleWorker:public Employee{
             workerMoney=baseMoney+x*0.05*profit;
         }
         void display(){
-            cout<<"销售员："<<getName()<<"\t"<<getId()<<"\t"<<workerMoney<<endl;
+            cout<<"销售员："<<getName()<<"\t"<<getId()<<"\t"<<workerMoney<<endl;
         }
 
     private:
@@ -56,7 +56,7 @@ class HourWorker:public Employee{
             TotalMoney=h*hourMoney;
         }
         void display(){
-            cout<<"小时工："<<getName()<<"\t"<<getId()<<"\t"<<TotalMoney<<endl;
+            cout<<"小时工："<<getName()<<"\t"<<getId()<<"\t"<<TotalMoney<<endl;
         }
     private:
         float hourMoney=100.0;
@@ -67,23 +67,23 @@ class HourWorker:public Employee{
 
 int main(int argc, char const *argv[])
 {
-    cout<<"请输入工作周：";
+    cout<<"请输入工作周：";
     int week;
     cin>>week;
-    Manager m("小王","11111111",week);
+    Manager m("小王","11111111",week);
     m.display();
-    cout<<"请输入销售利润：";
+    cout<<"请输入销售利润：";
     int profit;
     cin>>profit;
-    cout<<"请输入销售件数：";
+    cout<<"请输入销售件数：";
     int x;
     cin>>x;
-    SaleWorker s("小李","222222",profit,x);
+    SaleWorker s("小李","222222",profit,x);
     s.display();
-    cout<<"请输入工作小时：";
+    cout<<"请输入工作小时：";
     int hour;
     cin>>hour;
-    HourWorker h("小何","333333",hour);
+    HourWorker h("小何","333333",hour);
     h.display();
     system("pause");
     return 0;

practical_exercises/key_exercises/读写文件综合题.cpp

@@ -36,21 +36,21 @@ int main(int argc, char const *argv[])
     int Math,Chinese,English;
     fstream ioFile;
     ioFile.open("d:/per.dat",ios::out|ios::app);
-    cout<<"---------建立学生档案信息----------\n";
+    cout<<"---------建立学生档案信息----------\n";
     do{
-        cout<<"请输入姓名：";
+        cout<<"请输入姓名：";
         cin>>Name;
-        cout<<"请输入身份证号：";
+        cout<<"请输入身份证号：";
         cin>>Id;
-        cout<<"请输入数学成绩：";
+        cout<<"请输入数学成绩：";
         cin>>Math;
-        cout<<"请输入汉语成绩：";
+        cout<<"请输入汉语成绩：";
         cin>>Chinese;
-        cout<<"请输入英语成绩：";
+        cout<<"请输入英语成绩：";
         cin>>English;
         Person per(Name,Id,Math,Chinese,English);
         ioFile.write((char *)&per,sizeof(per));
-        cout<<"您是否继续建档？(Y/y)  ";
+        cout<<"您是否继续建档？(Y/y)  ";
         cin>>ch;
     }while(ch=='y'||ch=='Y');
     ioFile.close();
@@ -64,7 +64,7 @@ int main(int argc, char const *argv[])
         ioFile.read((char*)&p,sizeof(p));
     }
     ioFile.close();
-    cout<<"---------输出档案信息-----------"<<endl;
+    cout<<"---------输出档案信息-----------"<<endl;
     for(vt=v.begin();vt!=v.end();vt++){
         (*vt).display();
     }

practical_exercises/key_exercises/输入输出重载.cpp

@@ -26,13 +26,13 @@ Sales &operator<<(ostream&os,Sales &s){
 }
 
 Sales &operator>>(istream&is,Sales &s){
-    cout<<"输入雇员的姓名，身份证，年龄：\n";
+    cout<<"输入雇员的姓名，身份证，年龄：\n";
     is>>s.name>>s.id>>s.age;
 }
 
 int main(int argc, char const *argv[])
 {
-    Sales s("张三","15611",26);
+    Sales s("张三","15611",26);
     cout<<s;
     cin>>s;
     cout<<s;

practical_exercises/key_exercises/输出格式.cpp

@@ -9,9 +9,9 @@ int main(int argc, char const *argv[])
     cout<<setw(30)<<left<<setfill('*')<<s<<endl;
     cout<<dec<<setprecision(4)<<digit<<endl;
     cout<<dec<<15<<endl;
-    //setbase(int x)设置进制后，后面所有操作都是按照这个进制来计算！
+    //setbase(int x)设置进制后，后面所有操作都是按照这个进制来计算！
     cout<<setbase(10)<<15<<endl;
-    //四舍五入,并保留2位有效数组
+    //四舍五入,并保留2位有效数组
     float x=6.6937;
     cout<<float(int(x*1000+0.5)/1000.0)<<endl;
     system("pause");

practical_exercises/key_exercises/运算符重载之强制转换.cpp

@@ -1,12 +1,12 @@
 /*
-有一个类Circle，设计该类的类型转换函数，当将Circle对象转换成int型时，返回圆的半径；当将它转换成double型时，就返回圆的周长；当将它转换成float型时，就返回圆的面积。
+有一个类Circle，设计该类的类型转换函数，当将Circle对象转换成int型时，返回圆的半径；当将它转换成double型时，就返回圆的周长；当将它转换成float型时，就返回圆的面积。
 */
 
 /*
 
-类型转换函数没有参数。
+类型转换函数没有参数。
-类型转换函数没有返回类型。
+类型转换函数没有返回类型。
-类型转换函数必须返回将要转换成的type类型数据。
+类型转换函数必须返回将要转换成的type类型数据。
 
 */
 
@@ -23,10 +23,10 @@ public:
 };
 int main(){
     Circle c(2.3,3.4,2.5);
-    int r=c;        //调用operator int()，将Circle类型转换成int
+    int r=c;        //调用operator int()，将Circle类型转换成int
-    double length=c;   //调用operator double()，转换成double
+    double length=c;   //调用operator double()，转换成double
-    float area=c;   //调用operator float()，将Circle类型转换成float
+    float area=c;   //调用operator float()，将Circle类型转换成float
-    double len=(double) c;	//将Cirlce类型对象强制转换成double
+    double len=(double) c;	//将Cirlce类型对象强制转换成double
     cout<<r<<endl;
     cout<<length<<endl;
     cout<<len<<endl;