C++程序设计【二】之面向对象的基本概念

感谢内容提供者：金牛区吴迪软件开发工作室 接上一篇：C++程序设计【一】之 C++ 语言简介

文章目录

第二章：面向对象的基本概念

一、结构化程序设计

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

1.面向对象思想的提出

2.面向对象程序设计的特点

三、类的初步知识

1.类的定义

2.类的定义示例

PS:
public定义公有成员，可以被外部访问
private定义私有成员，只能被内部访问
protected定义保护成员，只能被内部或者继承类访问

#include <iostream>
#include <string>
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 = 1970, 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;
}
void myDate::setYear(int y) {
  year = y;
  return;
}
int myDate::getMonth() {
  return month;
}
void myDate::printDate() const {
  cout << year << "/" << month << "/" << day;
  return;
}

// 定义学生类
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;
}

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

四、类的示例程序剖析

1.程序结构

2.成员变量与成员函数的定义

3.创建类对象的基本形式

五、访问对象的成员

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

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;
}

2.使用指针访问对象的成员

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).setStudent()
  sp -> printStudent(); // 或者 (*sp).printStudent()
  return 0;
}

3.使用引用访问对象的成员

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

六、类成员的可访问范围

1.访问范围说明符的含义

PS：
默认值是私有的 private

2.成员的访问

1. 使用 protected 修饰的成员，可以在本类内及其子类内访问
2. 普通函数只能通过对象访问类的公有成员
3. 在类中，不作特别说明的数据成员均为私有类型
4. 类的对象只能访问公有成员
5. 类的私有成员可以在本类的成员函数中访问
6. 类本身的成员函数可以访问自己定义的任何成员

示例一：

#include <iostream>
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;
  cout << "Length of box:" << box.length << endl;   // 输出Length of box: 10;
  // 不使用成员函数设置宽度
  // box.width = 10.0;  会报错，因为width是私有的
  box.setWidth(10.0);   // 必须使用公有的成员函数设置宽度
  cout << "Width of box:" << box.getWidth() << endl;    // 输出Width of box: 10;
  return 0;
}

示例二：

#include <iostream>
#include <string>
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 = "Tom"   编译报错
  eT.setName("Tom");
  // eT.salary = 5000;  编译报错，不能直接访问私有成员
  eT.setSalary(5000);   // 需要通过公有成员函数访问
  cout << eT.getName() << endl; // 输出Tom
  eY.setName("Yong");
  eY.setSalary(3500);
  cout << eY.getName() << endl; // 输出Yong
  cout << "aver=" << eT.averageSalary(eY) << endl;
  return 0;
}

3.隐藏的作用

七、标识符的作用域与可见性

1.函数原型作用域

2.局部作用域

3.类作用域

4.命名空间作用域

5.作用域隐藏规则

下方代码中，主函数有嵌套的俩个块。外层块中定义了变量a，赋值1.内层块（for循环中）也定义了变量a，赋值2.这俩个变量相互独立。在for循环中，外层定义的变量a将不可见。

#include <iostream>
using namespace std;
int main() {
  int a = 1;
  cout << a << "\n";  // 输出1
  for (int i = 1; i < 2; i++) {
    int a = 2;
    cout << a << endl;  // 输出2
  }
  cout << a << endl;  // 输出1
  return 0;
}

下一篇：C++程序设计【三】之 类和对象进阶