前言
努力不一定成功，但是坚持做好一件事一定很酷。
在上一篇文章 C++学习——共勉（一） 中学习了C++语言的特点和程序结构，这篇文章就简单看看面向对象的基本概念。
一：结构化程序设计
在面向对象程序设计方法出现之前，软件界流行的主流设计方法之一就是结构化程序设计方法，也称为面向对象的设计方法。
在机构化程序设计中，采用自顶向下、逐步求精以及模块化思想，有个著名的公式体现了这一思想：数据结构+算法=程序。可以说，程序基本上都含有顺序、选择、循环3种基本控制结构。
对于比较大的文件，可以根据主函数和所定义的各个类以及全局函数的功能和相互关系，可以将类和全局函数划分为几个程序文件，包括 cpp. 文件（源程序文件）和 .h 文件（头文件）。
1：面向对象的程序设计
对象就是数据+函数，也就是属性+操作。举个简单的例子：员工的姓名、职位、工资等就是一个个变量；员工进行加班、出差、摸鱼划水，或者获得提拔、炒鱿鱼等就是操作；而操作会施加于属性，比如“加班、出差、摸鱼划水”操作会修改“工资”属性；“提拔、炒鱿鱼“操作会修改”职位“属性。
用对象名标识一个个对象，用数据表示对象的属性，再用函数实现操作。
C++中使用对象名、属性、操作三要素来描述对象。
2：类模型结构
类模型结构和对象结构很相似，它们都含有属性和操作，唯一不同的是对象结构图中有对象名而没有类名；类模型结构图中有类名但没有对象名。
二：创建类对象的基本形式
定义一个普通对象，即类变量的基本方法有两种：
方法一
方法二
例如，我们定义了一个类 A：
A b1，c1；//定义A类的对象b1和c1
A *p=&b1;//定义一个类型为A类的指针，指向对象b1
A &Q=c1；//定义A类类型对象C1的引用Q
A B[3];//定义A类类型对象的数组B，含有3个元素
三：类的初步知识
1：类的定义
面向对象方法中的类，是对具有相同属性中的同一类对象的抽象描述，其内部包括属性（本类的成员变量）和行为（本类的成员函数）两个主要部分，也就是类以数据为中心把相关的函数组成为一体。
在C++中，类定义的一般格式：
class 类名
{
访问范围说明符：
成员变量 1
成员变量 2
...
成员函数声明 1
成员函数声明 2
...
访问范围说明符：
更多成员变量
更多成员函数变量
}
“成员变量”是类中的一类成员，代表对象的属性，个数不限，也称为数据成员。成员变量的声明方式和普通变量的声明方式相同。“成员函数“是类中的另一类成员，代表对该类对象所含数据操作的方法，个数不限，其声明方式和普通函数的相同。
成员变量和成员函数的出现次序没有限制，一个类的成员函数之可以相互调用，类中可以不含有任何成员变量和成员函数，这样的类叫做“空类”。
成员函数既可以在类体内定义，也可以在类体外定义。如果成员函数定义在类体内部，则默认是内联函数
如果成员函数定义在类体外，则类体内必须要有函数原型，类体外函数定义的前面要有限定，格式为：
2：类成员的可访问范围
访问范围说明符一共有三种 public（公有），private（私有），protect（保护），在类的定义中可以以任意的次序出现多次。
| public | 使用它修饰的类成员可以在程序任何地方被访问 |
|---|---|
| private | 使用它修饰的类成员仅能在本类中被访问 |
| protect | 使用它修饰的类成员能在本类内和子类中被访问 |
class A
{
int m,n;
public:
int a,b;//公有成员变量
int func1();//公有成员函数
private:
int c,d;//私有成员变量
void func2();//私有成员函数
public:
char e;//公有成员变量
int f;//公有成员变量
int func3();//公有成员函数
}
类成员访问示例
#include <iostream>
#include <string>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
class Staff
{
private://私有成员
string name;
int salary;
public://公有成员
void setName(string);
string getName();
void setSalary(int);
int getSalary();
int averageSalary(Staff);
};
void Staff::setName(string myname)
{
name=myname;
}
string Staff::getName()
{
return name;
}
void Staff::setSalary(int mysalary)
{
salary=mysalary;
}
int Staff::getSalary()
{
return salary;
}
int Staff::averageSalary(Staff s1)
{
return (salary+s1.getSalary())/2;
}
int main(int argc, char** argv) {
Staff sL,sS;
sL.setName("Linda");//name 是私有变量，不能直接访问，需要通过公有成员setName来访问
sL.setSalary(12345);//salary 也是私有变量，需要借助公有成员 setSalary来访问
cout<<"第一个员工的姓名和薪水是："<<sL.getName()<<","<<sL.getSalary()<<endl;
sS.setName("Susan");
sS.setSalary(54321);
cout<<"第二个员工的姓名和薪水是："<<sS.getName()<<","<<sS.getSalary()<<endl;
cout<<"两个员工的平均薪水是："<<sL.averageSalary(sS)<<endl;
return 0;
}
输出结果：
3： 类的定义示例
//定义一个日期类myDate
class myDate
{
public:
myDate();//构造函数
myDate(int,int,int);//构造函数
void setDate(int,int,int);//设置日期
void setDate(myDate);//设置日期
myDate getDate();//获取日期
void setYear(int);//设置年
int getMonth();//获取月
void printDate() const;//打印日期 成员函数printDate（）需要使用const进行限定
private:
int year,month,day;//成员变量，表示年，月，日
};
//在类体外定义成员函数
myDate::myDate()
{ year=2022,month=1,day=1;
}//构造函数
myDate::myDate(int y,int m,int d)
{ year=y;month=m;day=d;
}//构造函数
void myDate::setDate(int y,int m,int d)
{ year=y;month=m;day=d;
return;
}//设置日期
void myDate::setDate(myDate oneD)
{ year=oneD.year;month=oneD.month;day=oneD.day;
return;
}//设置日期
myDate myDate::getDate()
{ return*this;
}//获取日期；*this是自身对象
void myDate::setYear(int y)
{ year=y;
return;
}//设置年
int myDate::getMonth()
{ return month;
}//设置月
void myDate::printDate()const
{ cout<<year<<"/"<<month<<"/"<<day;
return;
}//打印日期
//定义一个学生类Student
class Student
{
public:
void setStudent(string,myDate);//设置学生信息
void setName(string);//设置姓名
string getName();//获取姓名
void setBirthday(myDate);//设置生日
myDate getBirthday();//获取生日
void printStudent() const;//打印信息
private:
string name;
myDate birthday;
};
//在类体外定义成员函数
void Student::setStudent(string s,myDate d)
{ name=s;
birthday.setDate(d);
return;
}
void Student::setName(string n)
{ name=n;
return;
}
string Student::getName()
{ return name;
}
void Student::setBirthday(myDate d)
{ birthday.setDate(d);
return;
}
myDate Student::getBirthday()
{ return birthday;
}
void Student::printStudent() const
{ cout<<"姓名"<<name<<"/"<<"\t 生日";
birthday.printDate();//调用类myDate 的成员函数
cout<<endl;
}
四：访问对象的成员
1:使用对象访问成员变量与调用成员函数
定义了类和对象后就可以访问对象的成员。通过对象访问成员变量的一般格式：
调用成员函数的一般格式：
程序举例
验证Student 类功能的驱动程序
#include <iostream>
#include <string>
#include "myDate.h"
#include "Student.h"
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
int main(int argc, char** argv) {
Student ss;
int y,m,d;
string name_;
cout<<"请输入学生的姓名和生日" <<endl;
cin>>name_>>y>>m>>d;
ss.setStudent(name_,myDate(y,m,d));//创建Student的对象 ss，这里要考虑到成员名的访问范围，需要通过类Student 提供的公有访问方法即setStudent（）才能将键盘读入的字符串赋值给对象ss。
ss.printStudent();
return 0;
}
输出结果：
2：使用指针访问对象的成员
我们将程序主函数修改一下：
int main()
{ Student ss;
int y,m,d;
string name_;
Student *st=&ss;//指针st，指向ss，并使用&ss给指针赋初值
cout<<"请输入学生的姓名和生日";
cin>>name_>>y>>m>>d;
st->setStudent(name_,myDate(y,m,d));//指针操作符 指针名->成员名
st->printStudent();
return 0;
}
3：使用引用访问对象的成员
int main()
{
Student ss;
int y,m,d;
string name_;
Student &sn=ss;//ss的别名sn,sn和ss成为同一个对象的不同名字
cout<<"请输入学生的姓名和生日";
cin>>name_>>y>>m>>d;
sn.setStudent(name_,myDate(y,m,d));//访问成员时采用点操作符 引用名.成员名
sn.printStudent();
return 0;
五：标识符的作用域与可见性
1：函数原型作用域
在声明函数时原型时形参的作用范围就是函数原型作用域，这是c++程序中最小的作用域，生命周期最短：
函数原型作用域的作用范围就在括号中
2：局部作用域
3：类作用域
4：命名空间作用域
命名空间是为了消除同名引起的歧义，具有命名空间作用域的变量也叫做全局变量。定义命名空间的一般格式：
namespace 命名空间名
{
命名空间内的各种声明（函数声明等）
}
c++标准库中所有的标识符都定义在一个名为std 的命名空间中，因此在程序的示例部分中都出现了：using namespace std;
总结
当我们在实施自己的计划,追求自己的理想时,如果能够坚持下去,再坚持下去,或许我们在年老甚或离开人世的时候,会少一些遗憾。
如有不足，还请指正，感谢！
