From 368eda305fa067bddeb6e18685bd6942e807dc00 Mon Sep 17 00:00:00 2001
From: tracyxiong1 <xiongle_2005@qq.com>
Date: Mon, 2 Jan 2023 20:39:00 +0800
Subject: [PATCH] =?UTF-8?q?feat:=20=E7=BB=9F=E4=B8=80=20cpp=20=E6=96=87?=
 =?UTF-8?q?=E4=BB=B6=E7=BC=96=E7=A0=81=E6=A0=BC=E5=BC=8F=E4=B8=BA=20utf-8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../10_day_practice/day1/注释.cpp             |  8 ++--
 .../10_day_practice/day1/联合体学习.cpp       |  4 +-
 .../10_day_practice/day10/文件例题/12-1.cpp   |  8 ++--
 .../10_day_practice/day10/文件例题/12-3.cpp   |  2 +-
 .../10_day_practice/day10/文件例题/12-5.cpp   |  6 +--
 .../10_day_practice/day10/文件例题/12-6.cpp   | 12 ++---
 .../day10/文件例题/三种输入格式/get()12-2.cpp | 10 ++--
 .../文件例题/三种输入格式/getline()12-2-2.cpp | 20 ++++----
 .../day10/文件例题/重要!!!课堂练习.cpp        | 16 +++----
 .../10_day_practice/day2/掷骰子.cpp           |  2 +-
 .../10_day_practice/day2/枚举类型.cpp         |  2 +-
 .../10_day_practice/day2/汉诺塔.cpp           |  2 +-
 .../10_day_practice/day2/递归2.cpp            |  2 +-
 .../10_day_practice/day2/静态变量.cpp         | 14 +++---
 .../10_day_practice/day3/内联函数.cpp         |  4 +-
 .../10_day_practice/day3/函数综合练习题.cpp   | 24 +++++-----
 .../10_day_practice/day3/类前向声明.cpp       | 22 ++++-----
 .../10_day_practice/day3/静态成员函数1.cpp    |  8 ++--
 .../10_day_practice/day3/静态成员函数2.cpp    |  6 +--
 .../10_day_practice/day3/静态数据成员.cpp     | 14 +++---
 .../day4/const用法/常对象与常引用.cpp         |  4 +-
 .../day4/const用法/常对象与普通函数.cpp       | 22 ++++-----
 .../day4/友元函数/友元模块.cpp                |  8 ++--
 .../10_day_practice/day4/友元函数/友元类.cpp  | 10 ++--
 .../day4/拷贝构造函数/clock.cpp               |  6 +--
 .../基类与派生类关系/基类与派生类(重要).cpp   |  6 +--
 .../day5/构造函数与析构函数/构造顺序.cpp      |  6 +--
 .../构造函数与析构函数/派生类构造函数.cpp     |  2 +-
 .../派生类构造函数调用顺序.cpp                |  2 +-
 .../派生类给基类传递参数.cpp                  |  2 +-
 .../day5/继承访问权限/保护成员.cpp            | 16 +++----
 .../day5/继承访问权限/保护继承.cpp            | 20 ++++----
 .../day5/继承访问权限/公有继承.cpp            |  4 +-
 .../day5/虚拟继承/派生类初始化.cpp            |  4 +-
 .../day5/虚拟继承/虚基类调用次序(重要).cpp    |  2 +-
 .../day5/调用规则/直接基类与间接基类.cpp      |  2 +-
 .../day6/纯虚函数和抽象类/抽象类.cpp          | 10 ++--
 .../day6/虚函数/虚函数例子.cpp                | 26 +++++-----
 .../day6/虚函数/虚函数特性.cpp                | 10 ++--
 .../10_day_practice/day7/=号运算符/=例题.cpp  |  8 ++--
 .../day7/[]运算符/[]例题(重点).cpp            | 26 +++++-----
 .../day7/二元运算符/1.类运算符重载.cpp        | 10 ++--
 .../10_day_practice/day8/STL/map_se.cpp       | 14 +++---
 .../day8/函数模板/模板特化.cpp                | 14 +++---
 .../day8/函数模板/求最大值.cpp                | 12 ++---
 .../10_day_practice/day8/函数模板/重要.cpp    | 34 ++++++-------
 .../10_day_practice/day8/类模板/模拟栈.cpp    | 14 +++---
 .../day8/类模板/类模板特化.cpp                |  6 +--
 .../10_day_practice/day9/异常例子/2.cpp       |  2 +-
 .../10_day_practice/day9/异常例子/4.cpp       |  4 +-
 .../10_day_practice/day9/异常例子/7.cpp       |  4 +-
 .../10_day_practice/day9/异常例子/8.cpp       |  6 +--
 .../10_day_practice/day9/异常例子/9.cpp       |  4 +-
 .../key_exercises/字典插入与查找.cpp          | 48 +++++++++----------
 .../key_exercises/异常捕获.cpp                |  4 +-
 .../key_exercises/时钟++运算符重载.cpp        | 28 +++++------
 .../key_exercises/类模板之栈.cpp              |  4 +-
 .../key_exercises/类模板特化之数组.cpp        |  2 +-
 .../key_exercises/继承与封装.cpp              | 22 ++++-----
 .../key_exercises/读写文件综合题.cpp          | 16 +++----
 .../key_exercises/输入输出重载.cpp            |  4 +-
 .../key_exercises/输出格式.cpp                |  4 +-
 .../key_exercises/运算符重载之强制转换.cpp    | 16 +++----
 63 files changed, 327 insertions(+), 327 deletions(-)

diff --git a/practical_exercises/10_day_practice/day1/注释.cpp b/practical_exercises/10_day_practice/day1/注释.cpp
index 90931ac..d5cbf60 100644
--- a/practical_exercises/10_day_practice/day1/注释.cpp
+++ b/practical_exercises/10_day_practice/day1/注释.cpp
@@ -1,16 +1,16 @@
 #include<iostream>
 
 
-һ����������ָ��ע��
+一种条件编译指令注释
 
 
-//��һ��ע�ͷ���
+//另一种注释方法
 #if 0
 asd
 #endif
 
-//��ע��
-//��������ָ��
+//打开注释
+//条件编译指令
 #if 1
 asData
 #endif
diff --git a/practical_exercises/10_day_practice/day1/联合体学习.cpp b/practical_exercises/10_day_practice/day1/联合体学习.cpp
index c0adee0..e5ba04e 100644
--- a/practical_exercises/10_day_practice/day1/联合体学习.cpp
+++ b/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;
diff --git a/practical_exercises/10_day_practice/day10/文件例题/12-1.cpp b/practical_exercises/10_day_practice/day10/文件例题/12-1.cpp
index 2f1c9e4..3838863 100644
--- a/practical_exercises/10_day_practice/day10/文件例题/12-1.cpp
+++ b/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! 
-��������������
-����������Ӧ����������ij�Ա��������
+就难以输入啦！
+这样的数据应用输入流类的成员函数输入
 */
\ No newline at end of file
diff --git a/practical_exercises/10_day_practice/day10/文件例题/12-3.cpp b/practical_exercises/10_day_practice/day10/文件例题/12-3.cpp
index 1e314fe..8fa1969 100644
--- a/practical_exercises/10_day_practice/day10/文件例题/12-3.cpp
+++ b/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(){
diff --git a/practical_exercises/10_day_practice/day10/文件例题/12-5.cpp b/practical_exercises/10_day_practice/day10/文件例题/12-5.cpp
index 6c40322..edb386c 100644
--- a/practical_exercises/10_day_practice/day10/文件例题/12-5.cpp
+++ b/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");
 }
diff --git a/practical_exercises/10_day_practice/day10/文件例题/12-6.cpp b/practical_exercises/10_day_practice/day10/文件例题/12-6.cpp
index eaff91d..e228343 100644
--- a/practical_exercises/10_day_practice/day10/文件例题/12-6.cpp
+++ b/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<<"����"<<"  "<<89<<" "<<70<<" "<<60<<endl;
-    ioFile<<"��ʮ"<<"  "<<91<<" "<<88<<" "<<77<<endl;
-    ioFile<<"�ƶ�"<<"  "<<62<<" "<<81<<" "<<75<<endl;
-    ioFile<<"����"<<"  "<<90<<" "<<78<<" "<<67<<endl;
+    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; 
+    cout<<"姓名\t"<<"英语\t"<<"数学\t"<<"计算机\t"<<"总分"<<endl; 
     ioFile>>name;										
     while(!ioFile.eof())	{								
         ioFile>>chinese>>math>>computer;					
diff --git a/practical_exercises/10_day_practice/day10/文件例题/三种输入格式/get()12-2.cpp b/practical_exercises/10_day_practice/day10/文件例题/三种输入格式/get()12-2.cpp
index 99fe10a..af979ca 100644
--- a/practical_exercises/10_day_practice/day10/文件例题/三种输入格式/get()12-2.cpp
+++ b/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)
-���������������ַ��㹻��س�
-˵��������ǵ��ַ������룬��;������һ���ַ���������ASCALL����뵽a��
-������������cin��ͬ��cin.get()�ڻ���������[enter]��[space]��[tab]������Ϊ���������Ǽ������ڻ�������
+用法：a = cin.get() ?或者 ?cin.get(a)
+结束条件：输入字符足够后回车
+说明：这个是单字符的输入，用途是输入一个字符，把它的ASCALL码存入到a中
+处理方法：与cin不同，cin.get()在缓冲区遇到[enter]，[space]，[tab]不会作为舍弃，而是继续留在缓冲区中
 */
\ No newline at end of file
diff --git a/practical_exercises/10_day_practice/day10/文件例题/三种输入格式/getline()12-2-2.cpp b/practical_exercises/10_day_practice/day10/文件例题/三种输入格式/getline()12-2-2.cpp
index e6e0cef..cda1d14 100644
--- a/practical_exercises/10_day_practice/day10/文件例题/三种输入格式/getline()12-2-2.cpp
+++ b/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)������
-cin.get(arrayname,size)������[enter]ʱ�����Ŀǰ���룬������ɾ���������е�[enter]
-cin.getline(arrayname,size)������[enter]ʱ�������ǰ���룬���ǻ�ɾ���������е�[enter]
+（1）cin.getline(arrayname,size)与cin.get(arrayname,size)的区别
+cin.get(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*/
-    //cin.getline(arrayname,size,s)��cin.gei(arrayname,size,s)������
+	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
+    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����ɾ���������ģ�*/
+	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");
 }
diff --git a/practical_exercises/10_day_practice/day10/文件例题/重要!!!课堂练习.cpp b/practical_exercises/10_day_practice/day10/文件例题/重要!!!课堂练习.cpp
index d3050a0..f1dffd6 100644
--- a/practical_exercises/10_day_practice/day10/文件例题/重要!!!课堂练习.cpp
+++ b/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();				
diff --git a/practical_exercises/10_day_practice/day2/掷骰子.cpp b/practical_exercises/10_day_practice/day2/掷骰子.cpp
index 53c11a9..6671a17 100644
--- a/practical_exercises/10_day_practice/day2/掷骰子.cpp
+++ b/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();
diff --git a/practical_exercises/10_day_practice/day2/枚举类型.cpp b/practical_exercises/10_day_practice/day2/枚举类型.cpp
index c2191a5..334531e 100644
--- a/practical_exercises/10_day_practice/day2/枚举类型.cpp
+++ b/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;
diff --git a/practical_exercises/10_day_practice/day2/汉诺塔.cpp b/practical_exercises/10_day_practice/day2/汉诺塔.cpp
index 9bfefa3..9c31633 100644
--- a/practical_exercises/10_day_practice/day2/汉诺塔.cpp
+++ b/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');
diff --git a/practical_exercises/10_day_practice/day2/递归2.cpp b/practical_exercises/10_day_practice/day2/递归2.cpp
index 79c3560..bf5e1b6 100644
--- a/practical_exercises/10_day_practice/day2/递归2.cpp
+++ b/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;
diff --git a/practical_exercises/10_day_practice/day2/静态变量.cpp b/practical_exercises/10_day_practice/day2/静态变量.cpp
index be3bd0e..2fe4fbd 100644
--- a/practical_exercises/10_day_practice/day2/静态变量.cpp
+++ b/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;  // ��̬�ֲ���������ȫ���������ֲ��ɼ���
-    int b=-10;  // b, cΪ�ֲ����������ж�̬�����ڡ�
+    static int a;  // 静态局部变量，有全局寿命，局部可见。
+    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Ϊ��̬�ֲ�����������ȫ���������ֲ��ɼ���
-    //ֻ��һ�ν��뺯��ʱ����ʼ����
-    int c=10;   // CΪ�ֲ����������ж�̬������
-    //ÿ�ν��뺯��ʱ����ʼ����
+    // 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;
diff --git a/practical_exercises/10_day_practice/day3/内联函数.cpp b/practical_exercises/10_day_practice/day3/内联函数.cpp
index a95cddf..04c9cdd 100644
--- a/practical_exercises/10_day_practice/day3/内联函数.cpp
+++ b/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;
diff --git a/practical_exercises/10_day_practice/day3/函数综合练习题.cpp b/practical_exercises/10_day_practice/day3/函数综合练习题.cpp
index d1d2a2d..1fb09f8 100644
--- a/practical_exercises/10_day_practice/day3/函数综合练习题.cpp
+++ b/practical_exercises/10_day_practice/day3/函数综合练习题.cpp
@@ -1,9 +1,9 @@
 /*
-һԲ����Ӿ����ͼ��ʾ��������������Χ��һԲ�͹���������������Χ��դ����դ���۸�Ϊ35Ԫ/�ף��������Ϊ20Ԫ/ƽ���ס�
-��������Ϊ3�ף���Ӿ�ذ뾶�ɼ������롣Ҫ���̼��㲢���������դ������ۡ�
+一圆型游泳池如图所示，现在需在其周围建一圆型过道，并在其四周围上栅栏。栅栏价格为35元/米，过道造价为20元/平方米。
+过道宽度为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;
 }
diff --git a/practical_exercises/10_day_practice/day3/类前向声明.cpp b/practical_exercises/10_day_practice/day3/类前向声明.cpp
index e2483b5..ffa33d4 100644
--- a/practical_exercises/10_day_practice/day3/类前向声明.cpp
+++ b/practical_exercises/10_day_practice/day3/类前向声明.cpp
@@ -1,31 +1,31 @@
 /*
-ʹ��ǰ������������Ȼ���Խ��һЩ���⣬�������������ܵġ���Ҫע����ǣ�
-����ʹ����ǰ�������������������ṩһ��������������֮ǰ��������������Ķ���
-Ҳ������������Ա������ʹ�ø���Ķ����뿴����ij���Σ�
+使用前向引用声明虽然可以解决一些问题，但它并不是万能的。需要注意的是，
+尽管使用了前向引用声明，但是在提供一个完整的类声明之前，不能声明该类的对象，
+也不能在内联成员函数中使用该类的对象。请看下面的程序段：
 */
 
-//��һ��
+//第一种
 #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 {
 }; 
 
 /*
-�ܽ᣺��ʹ��ǰ����������ʱ��ֻ��ʹ�ñ������ķ��ţ��������漰����κ�ϸ�ڡ�
+总结：当使用前向引用声明时，只能使用被声明的符号，而不能涉及类的任何细节。
 */
\ No newline at end of file
diff --git a/practical_exercises/10_day_practice/day3/静态成员函数1.cpp b/practical_exercises/10_day_practice/day3/静态成员函数1.cpp
index 3edfa35..f99d2be 100644
--- a/practical_exercises/10_day_practice/day3/静态成员函数1.cpp
+++ b/practical_exercises/10_day_practice/day3/静态成员函数1.cpp
@@ -1,8 +1,8 @@
 /*
-֪ʶ�㣺
-��̬��Ա����
-����������ʹ������������������������þ�̬��Ա������
-��̬��Ա����ֻ���������ڸ���ľ�̬���ݳ�Ա��̬��Ա������
+知识点：
+静态成员函数
+类外代码可以使用类名和作用域操作符来调用静态成员函数。
+静态成员函数只能引用属于该类的静态数据成员或静态成员函数。
 */
 #include<iostream>
 using namespace std;
diff --git a/practical_exercises/10_day_practice/day3/静态成员函数2.cpp b/practical_exercises/10_day_practice/day3/静态成员函数2.cpp
index 168bb40..e999eb5 100644
--- a/practical_exercises/10_day_practice/day3/静态成员函数2.cpp
+++ b/practical_exercises/10_day_practice/day3/静态成员函数2.cpp
@@ -10,9 +10,9 @@ class A
 void A::f(A a)
 {
    
-    //��̬��Ա����ֻ���������ڸ���ľ�̬���ݳ�Ա��̬��Ա������
-    // cout<<x; //��x�������Ǵ����
-    cout<<a.x;  //��ȷ
+    //静态成员函数只能引用属于该类的静态数据成员或静态成员函数。
+    // cout<<x; //对x的引用是错误的
+    cout<<a.x;  //正确
 }
 
 int main(int argc, char const *argv[])
diff --git a/practical_exercises/10_day_practice/day3/静态数据成员.cpp b/practical_exercises/10_day_practice/day3/静态数据成员.cpp
index ae9c10c..6fd4f2b 100644
--- a/practical_exercises/10_day_practice/day3/静态数据成员.cpp
+++ b/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);	
diff --git a/practical_exercises/10_day_practice/day4/const用法/常对象与常引用.cpp b/practical_exercises/10_day_practice/day4/const用法/常对象与常引用.cpp
index 5a5567a..aacb8d2 100644
--- a/practical_exercises/10_day_practice/day4/const用法/常对象与常引用.cpp
+++ b/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�dz����󣬲��ܱ�����
+     A const a(3,4); //a是常对象，不能被更新
      system("pause");
      return 0;
 }
 void display(const double& r)
-//���������βΣ��ں����в��ܸ��� r�����õĶ���
+//常引用做形参，在函数中不能更新 r所引用的对象。
 {   cout<<r<<endl;   }
 
 
diff --git a/practical_exercises/10_day_practice/day4/const用法/常对象与普通函数.cpp b/practical_exercises/10_day_practice/day4/const用法/常对象与普通函数.cpp
index add9536..b8b658c 100644
--- a/practical_exercises/10_day_practice/day4/const用法/常对象与普通函数.cpp
+++ b/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�ؼ��ֿ��Ա����ڲ�������غ���������
-ͨ��������ֻ�ܵ������ij���Ա����
+常成员函数说明格式：类型说明符  函数名（参数表）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()
-    //ͨ��������ֻ�ܵ������ij���Ա����
+    a.print();  //调用void print()
+    //通过常对象只能调用它的常成员函数
     const R b(20,52);  
-    b.print();  //����void print() const
+    b.print();  //调用void print() const
     system("pause");
     return 0;
 }
diff --git a/practical_exercises/10_day_practice/day4/友元函数/友元模块.cpp b/practical_exercises/10_day_practice/day4/友元函数/友元模块.cpp
index 6bcc010..17ebd52 100644
--- a/practical_exercises/10_day_practice/day4/友元函数/友元模块.cpp
+++ b/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;//私有数据成员
 };
-//ͨ����һ��ģ������Ϊ��һ��ģ�����Ԫ��һ��ģ���ܹ����õ���һ��ģ���б��DZ����ص���Ϣ��
+//通过将一个模块声明为另一个模块的友元，一个模块能够引用到另一个模块中本是被隐藏的信息。
 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;
 }
diff --git a/practical_exercises/10_day_practice/day4/友元函数/友元类.cpp b/practical_exercises/10_day_practice/day4/友元函数/友元类.cpp
index 3d01fd0..cbbd431 100644
--- a/practical_exercises/10_day_practice/day4/友元函数/友元类.cpp
+++ b/practical_exercises/10_day_practice/day4/友元函数/友元类.cpp
@@ -1,13 +1,13 @@
 #include<iostream>
 using namespace std;
 /*
-��һ����Ϊ��һ�������Ԫ�����������г�Ա���ܷ��ʶԷ����˽�г�Ա��
-�����﷨������Ԫ��������һ������ʹ��friend����˵����
+若一个类为另一个类的友元，则此类的所有成员都能访问对方类的私有成员。
+声明语法：将友元类名在另一个类中使用friend修饰说明。
 */
 
 /*
-�������B����A�����Ԫ��B��ij�Ա�����Ϳ��Է���A���˽�кͱ������ݣ�
-��A��ij�Ա����ȴ���ܷ���B���˽�С��������ݡ�
+如果声明B类是A类的友元，B类的成员函数就可以访问A类的私有和保护数据，
+但A类的成员函数却不能访问B类的私有、保护数据。
 */
 class A{
   friend class B;
@@ -45,5 +45,5 @@ int main(int argc, char const *argv[])
 }
 
 /*
-�������B����A�����Ԫ��B��ij�Ա�����Ϳ��Է���A���˽�кͱ������ݣ���A��ij�Ա����ȴ���ܷ���B���˽�С���������
+如果声明B类是A类的友元，B类的成员函数就可以访问A类的私有和保护数据，但A类的成员函数却不能访问B类的私有、保护数据
 */
\ No newline at end of file
diff --git a/practical_exercises/10_day_practice/day4/拷贝构造函数/clock.cpp b/practical_exercises/10_day_practice/day4/拷贝构造函数/clock.cpp
index 702bf9e..355cb07 100644
--- a/practical_exercises/10_day_practice/day4/拷贝构造函数/clock.cpp
+++ 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);
diff --git a/practical_exercises/10_day_practice/day5/基类与派生类关系/基类与派生类(重要).cpp b/practical_exercises/10_day_practice/day5/基类与派生类关系/基类与派生类(重要).cpp
index eb54bb7..284f0be 100644
--- a/practical_exercises/10_day_practice/day5/基类与派生类关系/基类与派生类(重要).cpp
+++ b/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;		
diff --git a/practical_exercises/10_day_practice/day5/构造函数与析构函数/构造顺序.cpp b/practical_exercises/10_day_practice/day5/构造函数与析构函数/构造顺序.cpp
index 5afbc1e..9eaeb4a 100644
--- a/practical_exercises/10_day_practice/day5/构造函数与析构函数/构造顺序.cpp
+++ b/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
diff --git a/practical_exercises/10_day_practice/day5/构造函数与析构函数/派生类构造函数.cpp b/practical_exercises/10_day_practice/day5/构造函数与析构函数/派生类构造函数.cpp
index 0ec8c50..741faa6 100644
--- a/practical_exercises/10_day_practice/day5/构造函数与析构函数/派生类构造函数.cpp
+++ b/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){       //�����๹�캯���ij�ʼ���б�
+    Derived(int a,int b):Base(a){       //派生类构造函数的初始化列表
         y=b;
         cout<<"Derived constructor y="<<y<<endl;
     }
diff --git a/practical_exercises/10_day_practice/day5/构造函数与析构函数/派生类构造函数调用顺序.cpp b/practical_exercises/10_day_practice/day5/构造函数与析构函数/派生类构造函数调用顺序.cpp
index dcb812f..215b716 100644
--- a/practical_exercises/10_day_practice/day5/构造函数与析构函数/派生类构造函数调用顺序.cpp
+++ b/practical_exercises/10_day_practice/day5/构造函数与析构函数/派生类构造函数调用顺序.cpp
@@ -32,7 +32,7 @@ int main()
 }
 
 /*
-ִ�н����
+执行结果：
 Constructing C
 Constructing B
 Constructing A
diff --git a/practical_exercises/10_day_practice/day5/构造函数与析构函数/派生类给基类传递参数.cpp b/practical_exercises/10_day_practice/day5/构造函数与析构函数/派生类给基类传递参数.cpp
index 1138532..e28cb04 100644
--- a/practical_exercises/10_day_practice/day5/构造函数与析构函数/派生类给基类传递参数.cpp
+++ b/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;
     }
diff --git a/practical_exercises/10_day_practice/day5/继承访问权限/保护成员.cpp b/practical_exercises/10_day_practice/day5/继承访问权限/保护成员.cpp
index f044383..3e2189c 100644
--- a/practical_exercises/10_day_practice/day5/继承访问权限/保护成员.cpp
+++ b/practical_exercises/10_day_practice/day5/继承访问权限/保护成员.cpp
@@ -1,8 +1,8 @@
 /*
-������protected�ij�Ա
-���ڲ������Է���
-���ʹ���ߣ����ܷ���
-����������Ա�����Է���
+基类中protected的成员
+类内部：可以访问
+类的使用者：不能访问
+类的派生类成员：可以访问
 */
 #include<iostream>
 class B
@@ -19,16 +19,16 @@ class D: public B
 public:
 	void f() 
 	{	
-        i=1;//cannot access �����಻�ɷ��ʻ���˽�г�Ա
-		j=2;//��������Է��ʻ��ౣ����Ա	
+        i=1;//cannot access 派生类不可访问基类私有成员
+		j=2;//派生类可以访问基类保护成员	
         k=3;	
     }
 };
 int main()
 {	
     B b; 
-	b.i=1;//cannot access ˽�г�Ա�����ʹ���߲��ܷ���
-	b.j=2; //cannot access ������Ա�����ʹ���߲��ܷ���
+	b.i=1;//cannot access 私有成员，类的使用者不能访问
+	b.j=2; //cannot access 保护成员，类的使用者不能访问
 	b.k=3;
     system("pause");
     return 0;
diff --git a/practical_exercises/10_day_practice/day5/继承访问权限/保护继承.cpp b/practical_exercises/10_day_practice/day5/继承访问权限/保护继承.cpp
index a269f4e..0272779 100644
--- a/practical_exercises/10_day_practice/day5/继承访问权限/保护继承.cpp
+++ b/practical_exercises/10_day_practice/day5/继承访问权限/保护继承.cpp
@@ -1,7 +1,7 @@
 /*
-������ʽΪprotected�ļ̳г�Ϊ�����̳У������ּ̳з�ʽ�£�
-�����public��Ա���������л���protected��Ա��
-�����protected��private��Ա���������б���ԭ���ķ���Ȩ��
+派生方式为protected的继承称为保护继承，在这种继承方式下，
+基类的public成员在派生类中会变成protected成员，
+基类的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��Ա��
-�ⲿȥʹ�ñ�����Ա��ʱ�򣬻ᱨ��������setx��showx���ʴ��󣬶����������࣬���ֱ�ӷ��ʻ���ı�����Ա��
-���������У�y=getx()���������ʣ�
+解释：
+如最上面文字所示：保护继承会将基类的public变为protected，而对于protected成员，
+外部去使用保护成员的时候，会报错，所以setx与showx访问错误，而对于派生类，则可直接访问基类的保护成员，
+在派生类中，y=getx()可正常访问！
 */
\ No newline at end of file
diff --git a/practical_exercises/10_day_practice/day5/继承访问权限/公有继承.cpp b/practical_exercises/10_day_practice/day5/继承访问权限/公有继承.cpp
index bf74312..7aeea18 100644
--- a/practical_exercises/10_day_practice/day5/继承访问权限/公有继承.cpp
+++ b/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);	
diff --git a/practical_exercises/10_day_practice/day5/虚拟继承/派生类初始化.cpp b/practical_exercises/10_day_practice/day5/虚拟继承/派生类初始化.cpp
index 3e47cda..fede2c4 100644
--- a/practical_exercises/10_day_practice/day5/虚拟继承/派生类初始化.cpp
+++ b/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(){
diff --git a/practical_exercises/10_day_practice/day5/虚拟继承/虚基类调用次序(重要).cpp b/practical_exercises/10_day_practice/day5/虚拟继承/虚基类调用次序(重要).cpp
index 28718e0..dfac344 100644
--- a/practical_exercises/10_day_practice/day5/虚拟继承/虚基类调用次序(重要).cpp
+++ b/practical_exercises/10_day_practice/day5/虚拟继承/虚基类调用次序(重要).cpp
@@ -1,4 +1,4 @@
-//��Ҫ!!!
+//重要!!!
 #include <iostream>
 using namespace std;
 class A {
diff --git a/practical_exercises/10_day_practice/day5/调用规则/直接基类与间接基类.cpp b/practical_exercises/10_day_practice/day5/调用规则/直接基类与间接基类.cpp
index ab06668..a31411f 100644
--- a/practical_exercises/10_day_practice/day5/调用规则/直接基类与间接基类.cpp
+++ b/practical_exercises/10_day_practice/day5/调用规则/直接基类与间接基类.cpp
@@ -1,4 +1,4 @@
-//��ͬʱ����ֱ�ӻ���ͼ�ӻ���ʱ��ÿ��������ֻ������ֱ�ӻ���Ĺ��졣
+//当同时存在直接基类和间接基类时，每个派生类只负责其直接基类的构造。
 #include <iostream>
 using namespace std;
 class A { 
diff --git a/practical_exercises/10_day_practice/day6/纯虚函数和抽象类/抽象类.cpp b/practical_exercises/10_day_practice/day6/纯虚函数和抽象类/抽象类.cpp
index 7ee21ba..f733f01 100644
--- a/practical_exercises/10_day_practice/day6/纯虚函数和抽象类/抽象类.cpp
+++ b/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();
diff --git a/practical_exercises/10_day_practice/day6/虚函数/虚函数例子.cpp b/practical_exercises/10_day_practice/day6/虚函数/虚函数例子.cpp
index 1650141..589fafe 100644
--- a/practical_exercises/10_day_practice/day6/虚函数/虚函数例子.cpp
+++ b/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; }	//���þ�������н
-        float getSalary(){ return weeklySalary; }	//��ȡ��������н
-        void print(){			//��ӡ��������������֤����н
-            cout<<"������"<<getName()<<"\t\t ���: "<<getId()<<"\t\t �ܹ���: "<<getSalary()<<endl;
+        void setSalary(float s) { weeklySalary=s; }	//设置经理的周薪
+        float getSalary(){ return weeklySalary; }	//获取经理的周薪
+        void print(){			//打印经理姓名、身份证、周薪
+            cout<<"经理："<<getName()<<"\t\t 编号: "<<getId()<<"\t\t 周工资: "<<getSalary()<<endl;
         }
     private:
-        float weeklySalary; //��н
+        float weeklySalary; //周薪
 };
 
 
 /*
-�������ָ�ֵ��ʽ����ֻ��ͨ��������󣨻��������ָ������ã����ʵ����������ӻ����м̳е��ij�Ա�� 
-���ܽ�˷��������ඨ��ij�Ա�����麯��ʹ�ÿ���ͨ����������ָ������÷��������ඨ��ij�Ա��
+不论哪种赋值方式，都只能通过基类对象（或基类对象的指针或引用）访问到派生类对象从基类中继承到的成员， 
+不能借此访问派生类定义的成员。而虚函数使得可以通过基类对象的指针或引用访问派生类定义的成员。
 */
 int main(){
-    Employee e("��","NO0001"),*pM;
-    Manager m("��","NO0002",128);
+    Employee e("小米","NO0001"),*pM;
+    Manager m("小汪","NO0002",128);
     m.print();
     pM=&m;
     pM->print();
@@ -63,4 +63,4 @@ int main(){
     system("pause");
     return 0;
 }
-//Virtual�ؼ�����ʵ���Ǹ�֪����ϵͳ����ָ��Ϊvirtual�ĺ������ö�̬�������ʽ���롣
+//Virtual关键字其实质是告知编译系统，被指定为virtual的函数采用动态联编的形式编译。
diff --git a/practical_exercises/10_day_practice/day6/虚函数/虚函数特性.cpp b/practical_exercises/10_day_practice/day6/虚函数/虚函数特性.cpp
index 8ee62f7..287243d 100644
--- a/practical_exercises/10_day_practice/day6/虚函数/虚函数特性.cpp
+++ b/practical_exercises/10_day_practice/day6/虚函数/虚函数特性.cpp
@@ -13,7 +13,7 @@ class C: public B {
 public: 
     void f(int i){cout<<"C::f()"<<endl;}
 };
-//һ����ij����Ա��������Ϊ�麯�������ڼ̳���ϵ�о���ԶΪ�麯���� 
+//一旦将某个成员函数声明为虚函数后，它在继承体系中就永远为虚函数了 
 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
-    pB=&b;    pB->f(1);		//����B::f
-    pB=&c;    pB->f(1);		//����C::f
-    pB=&d;    pB->f(1);		//����D::f
+    pA=&a;    pA->f(1);		//调用A::f
+    pB=&b;    pB->f(1);		//调用B::f
+    pB=&c;    pB->f(1);		//调用C::f
+    pB=&d;    pB->f(1);		//调用D::f
     system("pause");
     return 0;
 }
diff --git a/practical_exercises/10_day_practice/day7/=号运算符/=例题.cpp b/practical_exercises/10_day_practice/day7/=号运算符/=例题.cpp
index b3e8d12..7b1ce0f 100644
--- a/practical_exercises/10_day_practice/day7/=号运算符/=例题.cpp
+++ b/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.operator= (obj2); //�������ء�=��
-	obj1 = obj2 = obj3;    //�������ء�=��
+	obj1 = obj2;          //调用重载“=”
+	obj1.operator= (obj2); //调用重载“=”
+	obj1 = obj2 = obj3;    //调用重载“=”
     system("pause");
 }
diff --git a/practical_exercises/10_day_practice/day7/[]运算符/[]例题(重点).cpp b/practical_exercises/10_day_practice/day7/[]运算符/[]例题(重点).cpp
index 88a3d2a..77bc4f5 100644
--- a/practical_exercises/10_day_practice/day7/[]运算符/[]例题(重点).cpp
+++ b/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;          	 //���ְ����Ϣ������
-		int max;                  		//�����±��Ͻ�
-		int n;                    		//�����е�ʵ��ְ������
+		Person *employ;          	 //存放职工信息的数组
+		int max;                  		//数组下标上界
+		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["��˹"]=1230.07;
-    s["����"]=3200.97;
-    cout<<"����\t"<<s["����"]<<endl;          cout<<"��˹\t"<<s["��˹"]<<endl;
-    cout<<"����\t"<<s["����"]<<endl;
+    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";
+    cout<<"-------下为display的输出--------\n\n";
     s.display();
     system("pause");
 }
diff --git a/practical_exercises/10_day_practice/day7/二元运算符/1.类运算符重载.cpp b/practical_exercises/10_day_practice/day7/二元运算符/1.类运算符重载.cpp
index 0c52a2e..c6c5bdb 100644
--- a/practical_exercises/10_day_practice/day7/二元运算符/1.类运算符重载.cpp
+++ b/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=2+b;       			//����   
+    a=b+2;       			//正确
+    // a=2+b;       			//错误   
     a.display();  
     c3=c1+c2;
     c4=c1-c2;
diff --git a/practical_exercises/10_day_practice/day8/STL/map_se.cpp b/practical_exercises/10_day_practice/day8/STL/map_se.cpp
index 6edc186..3943ebb 100644
--- a/practical_exercises/10_day_practice/day8/STL/map_se.cpp
+++ b/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;
     }
diff --git a/practical_exercises/10_day_practice/day8/函数模板/模板特化.cpp b/practical_exercises/10_day_practice/day8/函数模板/模板特化.cpp
index d0d303f..06820f7 100644
--- a/practical_exercises/10_day_practice/day8/函数模板/模板特化.cpp
+++ b/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<<"c,d�����ֵ�ǣ�"<<Max(c,d)<<endl;   
+    cout<<"2,3的最大值是："<<Max(3,2)<<endl;   
+    cout<<"c,d的最大值是："<<Max(c,d)<<endl;   
     cout<<Max("xbv","xyce")<<endl;         
     system("pause");
 }
 /*
-�� ��������ͬʱ����ģ��������ػ�ʱ���ػ��������ȵ��ã�
-�� ��ͬһ�������У����˺���ģ��������ػ��⣬��������ͬ������ͨ����������������C++�����ͨ�����ĵ���ʵ�ν�����ʽ������ת����
-�������ģ�庯�����ػ������IJ��������κ���ʽ������ת����
+① 当程序中同时存在模板和它的特化时，特化将被优先调用；
+② 在同一个程序中，除了函数模板和它的特化外，还可以有同名的普通函数。其区别在于C++会对普通函数的调用实参进行隐式的类型转换，
+但不会对模板函数及特化函数的参数进行任何形式的类型转换。
 
 */
\ No newline at end of file
diff --git a/practical_exercises/10_day_practice/day8/函数模板/求最大值.cpp b/practical_exercises/10_day_practice/day8/函数模板/求最大值.cpp
index 69295a5..def858b 100644
--- a/practical_exercises/10_day_practice/day8/函数模板/求最大值.cpp
+++ b/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<<"a, c    �����ֵ�ǣ�"<<Max(float(a),c)<<endl;
-    //��ʾָ������ģ��ʵ�����IJ�������
-    cout<<"'a', 3    �����ֵ�ǣ�"<<Max<int>('a',3)<<endl;
+    //在模板调用时进行参数类型的强制转换
+    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");
 }
 
diff --git a/practical_exercises/10_day_practice/day8/函数模板/重要.cpp b/practical_exercises/10_day_practice/day8/函数模板/重要.cpp
index c49f07a..361d53b 100644
--- a/practical_exercises/10_day_practice/day8/函数模板/重要.cpp
+++ b/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������һ����Ȼ��������ͬ����ĸ��ɣ��������Dz�ͬ�ġ�
-�����class��ʾT��һ�����Ͳ������������κ��������ͣ���int��float��char�ȣ������û������struct��enum��class���Զ����������͡�
+不要把这里的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>д���������ʽ����ȫ�ȼ۵ģ�
+为了区别类与模板参数中的类型关键字class，标准C++提出?了用typename作为模板参数的类型关键字，同时也支持使用class。
+比如，把min定义的template <class T>写成下面的形式是完全等价的：
 */
 template <typename T>
 T myMin(T a, T b){
@@ -20,22 +20,22 @@ T myMin(T a, T b){
 }
 
 /*
-ģ��ʵ���������ڵ���ģ�庯��ʱ�������������������жԺ���ģ��ĵ���ʱ��
-���Ż���ݵ��������ʵ�εľ������ͣ�ȷ��ģ��������������ͣ�
-���ô������滻����ģ���е�ģ������������ܹ����������͵ĺ������룬��ģ�庯����
-����η���������ͬ�IJ�������ʱ��ֻ�ڵ�1�ν���ʵ������������ֻ�ڵ�1�ε���ʱ����ģ�庯����
-��֮��������ͬ���͵IJ�������ʱ��������������ģ�庯�����������õ�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.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
+    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;
 }
diff --git a/practical_exercises/10_day_practice/day8/类模板/模拟栈.cpp b/practical_exercises/10_day_practice/day8/类模板/模拟栈.cpp
index be2337f..757ef00 100644
--- a/practical_exercises/10_day_practice/day8/类模板/模拟栈.cpp
+++ b/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(); 
diff --git a/practical_exercises/10_day_practice/day8/类模板/类模板特化.cpp b/practical_exercises/10_day_practice/day8/类模板/类模板特化.cpp
index 3d84935..cd520e5 100644
--- a/practical_exercises/10_day_practice/day8/类模板/类模板特化.cpp
+++ b/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++){
diff --git a/practical_exercises/10_day_practice/day9/异常例子/2.cpp b/practical_exercises/10_day_practice/day9/异常例子/2.cpp
index c9ba425..05350d7 100644
--- a/practical_exercises/10_day_practice/day9/异常例子/2.cpp
+++ b/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...";
diff --git a/practical_exercises/10_day_practice/day9/异常例子/4.cpp b/practical_exercises/10_day_practice/day9/异常例子/4.cpp
index df68379..fcc4fff 100644
--- a/practical_exercises/10_day_practice/day9/异常例子/4.cpp
+++ b/practical_exercises/10_day_practice/day9/异常例子/4.cpp
@@ -3,8 +3,8 @@ using namespace std;
 void temperature(int t)
 {
     
-    if(t==100) throw "�е㣡";
-    else if(t==0) throw "���㣡";
+    if(t==100) throw "沸点！";
+    else if(t==0) throw "冰点！";
     else{cout<<"temperatore="<<t<<endl;}
    
 }
diff --git a/practical_exercises/10_day_practice/day9/异常例子/7.cpp b/practical_exercises/10_day_practice/day9/异常例子/7.cpp
index ce12f6e..54613e0 100644
--- a/practical_exercises/10_day_practice/day9/异常例子/7.cpp
+++ b/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(){
diff --git a/practical_exercises/10_day_practice/day9/异常例子/8.cpp b/practical_exercises/10_day_practice/day9/异常例子/8.cpp
index bd6a058..62ea461 100644
--- a/practical_exercises/10_day_practice/day9/异常例子/8.cpp
+++ b/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 Empty{};	//L2  ��ջ��ʱ�׳����쳣��
+class Full{};	//L1  堆栈满时抛出的异常类
+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;
diff --git a/practical_exercises/10_day_practice/day9/异常例子/9.cpp b/practical_exercises/10_day_practice/day9/异常例子/9.cpp
index 09b0e2a..39611dc 100644
--- a/practical_exercises/10_day_practice/day9/异常例子/9.cpp
+++ b/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;}
diff --git a/practical_exercises/key_exercises/字典插入与查找.cpp b/practical_exercises/key_exercises/字典插入与查找.cpp
index bf7f6b9..762c797 100644
--- a/practical_exercises/key_exercises/字典插入与查找.cpp
+++ b/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<<"��ʼɾ��Ԫ�أ�"<<endl;
+        cout<<iter->first<<"按照key查找出来了！"<<"对应的value为："<<iter->second<<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<<"��ʼɾ��Ԫ�أ�"<<endl;
+            cout<<iter->first<<"按照key查找出来了！"<<"对应的value为："<<iter->second<<endl;
+            cout<<"开始删除元素！"<<endl;
             mp.erase(iter);
             break;
         }
         if(strcmp(iter->second,drop_value)==0){
-            cout<<iter->second<<"value���ҳ����ˣ�"<<"��Ӧ��keyΪ��"<<iter->first<<endl;
-            cout<<"��ʼɾ��Ԫ�أ�"<<endl;
+            cout<<iter->second<<"value查找出来了！"<<"对应的key为："<<iter->first<<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;
     }
diff --git a/practical_exercises/key_exercises/异常捕获.cpp b/practical_exercises/key_exercises/异常捕获.cpp
index 80fe506..d6d937b 100644
--- a/practical_exercises/key_exercises/异常捕获.cpp
+++ b/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;
diff --git a/practical_exercises/key_exercises/时钟++运算符重载.cpp b/practical_exercises/key_exercises/时钟++运算符重载.cpp
index fbddebc..ea93d2e 100644
--- a/practical_exercises/key_exercises/时钟++运算符重载.cpp
+++ b/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��   
-    //��ִ��myClock++����ʱmyClock=00:00:00   
+    //先执行ShowTime()，输出myClock=23:59:59，   
+    //再执行myClock++，此时myClock=00:00:00   
     (myClock++).ShowTime();   
   
-    cout<<"ִ��++myClock���ʱ��Ϊ:\t";   
+    cout<<"执行++myClock后的时间为:\t";   
   
-    //��ִ��++myClock����ʱmyClock=00:00:01   
-    //��ִ��ShowTime()�����myClock=00:00:01   
+    //先执行++myClock，此时myClock=00:00:01   
+    //再执行ShowTime()，输出myClock=00:00:01   
     (++myClock).ShowTime();   
     system("pause");
 }  
\ No newline at end of file
diff --git a/practical_exercises/key_exercises/类模板之栈.cpp b/practical_exercises/key_exercises/类模板之栈.cpp
index 6d05646..3276c8c 100644
--- a/practical_exercises/key_exercises/类模板之栈.cpp
+++ b/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;
     }
 }
diff --git a/practical_exercises/key_exercises/类模板特化之数组.cpp b/practical_exercises/key_exercises/类模板特化之数组.cpp
index 6e768a1..6844d7f 100644
--- a/practical_exercises/key_exercises/类模板特化之数组.cpp
+++ b/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];
diff --git a/practical_exercises/key_exercises/继承与封装.cpp b/practical_exercises/key_exercises/继承与封装.cpp
index 1f949e9..0f758c5 100644
--- a/practical_exercises/key_exercises/继承与封装.cpp
+++ b/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;
diff --git a/practical_exercises/key_exercises/读写文件综合题.cpp b/practical_exercises/key_exercises/读写文件综合题.cpp
index fd3f7c7..003fd08 100644
--- a/practical_exercises/key_exercises/读写文件综合题.cpp
+++ b/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();
     }
diff --git a/practical_exercises/key_exercises/输入输出重载.cpp b/practical_exercises/key_exercises/输入输出重载.cpp
index 98c4db3..601436a 100644
--- a/practical_exercises/key_exercises/输入输出重载.cpp
+++ b/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;
diff --git a/practical_exercises/key_exercises/输出格式.cpp b/practical_exercises/key_exercises/输出格式.cpp
index 3083da7..5634c19 100644
--- a/practical_exercises/key_exercises/输出格式.cpp
+++ b/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");
diff --git a/practical_exercises/key_exercises/运算符重载之强制转换.cpp b/practical_exercises/key_exercises/运算符重载之强制转换.cpp
index 662fcd1..c43a48c 100644
--- a/practical_exercises/key_exercises/运算符重载之强制转换.cpp
+++ b/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
-    double length=c;   //����operator double()��ת����double
-    float area=c;   //����operator float()����Circle����ת����float
-    double len=(double) c;	//��Cirlce���Ͷ���ǿ��ת����double
+    int r=c;        //调用operator int()，将Circle类型转换成int
+    double length=c;   //调用operator double()，转换成double
+    float area=c;   //调用operator float()，将Circle类型转换成float
+    double len=(double) c;	//将Cirlce类型对象强制转换成double
     cout<<r<<endl;
     cout<<length<<endl;
     cout<<len<<endl;