面向对象的基本概念

一、结构化程序设计

结构化程序设计方法，也称为面向过程的设计方法。它强调数据类型和程序结构，注重程序的易读性、可靠性和可维护性。
在结构化程序设计中，采用 自顶向下、逐步求精及模块化的思想。

程序设计的过程基本上就是编写函数的过程。

程序基本上都含有顺序、选择和循环3种基本控制结构。
程序化结构设计主要强调的就是程序的易读性。
基本思想：数据结构+算法=程序。

二、面向对象程序设计的概念和特点

是20世纪90年代以来软件开发方法的主流。

所谓面向对象的程序设计方法，就是使分析、设计和实现一个系统的方法尽可能地接近人们认识一个系统的方法。通常包括：面向对象的分析、面向对象的设计和面向对象的程序设计。

对象具有两个特性：
1.状态：是指对象本身的信息，也称为属性。
2.行为：是对对象的操作。

类是面向对象程序设计方法中的程序主体。

面向对象的程序设计有：抽象、封装、继承和多态4个基本特点。

在面向对象程序设计中，将一组数据和这组数据有关的操作集合组装在一起形成对象，叫做抽象。

对象的特点：属性和操作。

把对象的属性和操作结合成一个独立的系统单位，并尽可能隐蔽对象的内部细节叫做封装。
C++语言通过建立用户定义的类来支持数据封装和信息隐藏。

继承是面向对象程序设计的一个重要特性，是软件复用的一种形式，它允许在原有类的集成上创建新的类。

多态是指不同种类的对象都具有名称相同的行为，而具体行为的实现方式却有所不同。

三、类的初步认识

在C++中，向int或double这样的类型是系统预定义的，称为基本数据类型。

类以数据为中心，把相关的一批函数组成为一体。
定义类以称为说明类。
在C++中，类定义的一般格式

class 类名
{
  访问范围说明符:
        成员变量1
        成员变量2
        ...
        成员函数声明1
        成员函数声明2
        ...
  访问范围说明符:
      更多成员变量
      更多成员函数声明
      ...
};

类以关键字class开始，后面是类名。类名的定义遵循一般的标识符命名规则，即字母、下划线和数字的组合，大小写敏感，但不能以数字开头，也不能和系统中使用的关键字完全相同。
类是具有唯一标识符的实体，类名不能重复。

访问范围说明符一共有public(公有)、private(私有)和protected(保护)3种。

成员变量是类中的一类成员，个数不限，也称为数据成员。代表对象的属性。声明方式与普通变量的声明相同。

在C++98标准下，类中声明的任何成员不能使用auto、extern和register关键字进行修饰。

如果成员函数定义在类体外，则类体内必须要有函数原型，类体外函数定义的前面必须用“类名::"来限定

返回值类型 类名::成员函数名(参数列表)
{
  成员函数的函数体
}

在一般情况下，将类的成员变量声明为私有的，以便隐藏数据。

程序2-1定义一个表示日期的类myDate。3个基本属性：年、月、日，用year、month和day表示。

程序2-1 定义日期类myDate

#include 
using namespace std;
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;     //打印日期
    private:
        int year,month,day;     //成员变量，表示年、月、日 
 };
//在类体外定义成员函数
myDate::myDate()
{
    year = 1997,month = 2,day = 12;
 } 
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;
}
void myDate::setYear(int y){
    year = y;
    return; 
}
int myDate::getMonth()
{
    return month;
}
void myDate::printDate() const
{
    cout<

程序2-2 定义学生类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<<"姓名："<

四、类的示例程序剖析

(一)、程序结构

一个完整的C++程序包括以下儿部分。
●一个主函数，可以调用其他函数，但不能被调用，也称为主程序。
●用户定义的任意多个的类及全局函数。
●全局说明。在所有函数和类定义之外的变量说明及函数原型。
●注释。
●头文件。

从逻辑关系上看，典型的C++程序的结构包括类的定义、类中成员函数的实现和主函数main。

成员变量一般均定义为私有访问权限，仅能在本类内访问。如果要从类外访问，则需要为成员变量定义相应的访问函数，然后通过访问函数来访问私有的成员变量。

实现成员函数时要指明类的名称，

返回值类型 类名::函数成员名(参数表)
{
   函数体
}

定义一个普通对象，即类变量的基本方法有两种。
(1)

类名 对象名；
或是
类名 对象名(参数);
或是
类名 对象名 = 类名(参数);

(2)

类名 *对象指针名 = new 类名;
或是
类名 *对象指针名 = new 类名();
或是
类名 *对象指针名 = new 类名(参数);

用new创建对象时返回的是一个对象指针，这个指针指向本类刚创建的这个对象。
C++分配给指针的仅仅是存储指针值的空间，而对象所占用的空间分配在堆上。

声明对象引用即变量别名的基本格式

类名 &对象引用名 = 对象;

声明对象指针，即指向对象的指针的基本格式
类名 对象指针名 = 对象的地址;

声明对象数组的格式
类名 对象数组名[数组大小];

同类型的对象之间可以相互赋值。例如，定义了类C后，

C a1,b1;  //定义了C类的对象a1和b1
C *p = &a1;  //定义了指向对象a1的C类类型的指针p
C &R = b1;  //定义了C类类型对象b1的引用R 
C A[3];  //定义了C类类型对象的数组A，含3个元素

程序运行中，创建对象就是为对象分配内存。

五、访问对象的成员

使用对象访问成员变量与调用成员函数

通过对象访问成员变量的一般格式：

对象名.成员变量名

调用成员函数的格式

对象名.成员函数名(参数表)

例如，可以写一个驱动程序。
程序2-3 验证类功能的驱动程序

#include 
#include 
#include "myDate.cpp";
#include "Student.cpp";
using namespace std;

int main() {
    Student ss;
    int y,m,d;
    string name_;
    cout<<"请输入学生的姓名和生日，生日以\”年 月 日\"的次序输入：";
    cin>>name_>>y>>m>>d;
    ss.setStudent(name_,myDate(y,m,d));
    ss.printStudent();
    return 0;
} 

请输入学生的姓名和生日，生日以”年 月 日"的次序输入：
薛怀 1997 02 12
姓名：薛怀      生日：1997/2/12

使用指针访问对象的成员

如果是通过指针访问成员变量，则点运算符.换位箭头运算符->

指针->成员名

程序2-4 使用指针方式的驱动程序

#include 
#include 
#include "myDate.cpp";
#include "Student.cpp";

int main()
{
    Student ss;
    int y,m,d;
    string name_;
    Student *sp = &ss;  //指向ss的指针sp
    
    cout<<"请输入学生的姓名和生日，生日以\”年 月 日\"的次序输入：";
    cin>>name_>>y>>m>>d;
    sp->setStudent(name_,myDate(y,m,d));
    sp->printStudent();
    return 0;
}

使用引用访问对象的成员

可以在程序中直接定义引用并进行初始化。
程序2-5 使用引用方式的驱动程序

#include 
#include 
#include "myDate.cpp";
#include "Student.cpp";

int main()
{
    Student ss;
    int y,m,d;
    string name_;
    Student &sy = ss;   //ss的别名sy 
    
    cout<<"请输入学生的姓名和生日，生日以\”年 月 日\"的次序输入：";
    cin>>name_>>y>>m>>d;
    sy.setStudent(name_,myDate(y,m,d));
    sy.printStudent();
    return 0;
}

六、类成员的可访问范围

访问范围说明符的含义

public的含义是公有的，使用它修饰的类的成员可以在程序的任何地方被访问。
private的含义是私有的，使用它修饰的类的成员仅能在本类内被访问。
protected的含义是保护的，它的作用介于public和private之间，使用它修饰的类的成员能在本类内及子类中被访问。
如果某个成员前面没有访问范围说明符，则默认该成员为私有成员。
例2-7 访问范围说明符

class Line
{
    private:
        double length;
    public:
        void setLength(double);
        double getLength();
    private:
        double area;
        bool isEmpty();
};

例2-8
class A
{
        int m,n;
    public:
        int a,b;
        int func1();
    private:
        int c,d;
        void func2();
    public:
        char e;
        int f;
        int func3();
};

成员的访问

程序2-6 类成员的访问

#include 
using namespace std;
class Box
{
    public:             //公有的
        double length;
        void setWidth(double wid);
        double getWidth();
    private:        //私有的 
        double width;
};
//类体外定义成员函数
double Box::getWidth()
{
    return width;
 } 
void Box::setWidth(double wid)
{
    width = wid;
}
int main()
{
    Box box;        //声明一个对象
    //不使用成员函数设置长度
    box.length = 10.0;      //正确，因为length是公有的
    cout<<"Length of box:"<< box.length<

程序2-7 类成员访问示例

#include 
#include 
using namespace std;

class CEmployee
{
    private:
        string szName;      //姓名
        int salary;     //工资
    public:
        void setName(string);   //设置姓名
        string getName();   //获取姓名
        void setSalary(int);    //设置工资
        int getSalary();    //获取工资
        int averageSalary(CEmployee);   //计算两人的平均工资 
};

void CEmployee::setName(string name)
{
    szName = name;
}
string CEmployee::getName()
{
    return szName;
}
void CEmployee::setSalary(int mon)
{
    salary = mon;
}

int CEmployee::getSalary()
{
    return salary;
}

int CEmployee::averageSalary(CEmployee e1)
{
    return (salary + e1.getSalary())/2;
}

int main()
{
    CEmployee eT,eY;        
    //eT.szName = "Tom1234567";     //编译错误，不能直接访问私有成员
    eT.setName("Tom1234567");   //需要通过公有成员函数访问
    //eT.salary = 5000; //编译错误，不能直接访问私有成员
    eT.setSalary(5000);
    cout<

例题,输出程序结果

#include 
using namespace std;
class Test
{
    int a,b;
    int getmin()
    {
        return (a
using namespace std;
class MyClassType1
{
    private:
        int x,y;
    public:
        int getx()
        {
            return x;
        }
        int gety();
        void setx(int x0)
    {
        x = x0;
    }
    void sety(int y0);
    void displayx()
    {
        cout<<"x="<

程序设计

/*
*   04737 c++ 自学考试2019版 第二章课后练习
*   程序设计题 1
*   需求:设计并实现一个类Course.它代表学校中的一门课程..... 
*/

//标准流 
#include
//标准字符
#include 
using namespace std;

class Course{
    private:
        //课程名 
        string courseName;
        //学分 
        int score; 
        //学时数
        int hours;
        //课程类别
        string category;
        //授课专业 
        string professional;
    public:
        //无参构造器
        Course(); 
        //有参构造器
        Course(string courseName,string category,string professional,int score,int hours);
        //声明getter
        string getCourseName();
        string getCategory();
        string getProfessional();
        int getScore();
        int getHours();
        //声明setter
        void setCourseName(string str);
        void setCategory(string str);
        void setProfessional(string str);
        void setScore(int a);
        void setHours(int a);
        //声明 打印所有数据函数 
        void showInfo(); 
};
//定义无参构造
Course::Course()
{
    cout<<"The no-argument constructor is running"<