C++ 面向对象学习笔记-1

C++在 C 语言的基础上增加了面向对象编程，C++支持面向对象程序设计，类是 C++的核心特性，通常被称为用户定义的类型，类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法，类中的数据和方法称为类的成员，函数在类中被称为类的成员

一、类的定义

定义一个类，本质上是定义一个数据类型的蓝图，实际上并没有定义任何数据，但它定义了类的名称的意义是什么，也就是说，它定义了类的对象包括了什么，以及可以在这个对象上执行的哪些操作
定义类是以关键字 class 开头，后面跟上类的名称，类的主体是包含在一对花括号中，类定义后必须跟着一个分号或一个声明列表，例如，我们使用关键字 class 定义 Bog 数据类型，如下所示：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


class Dog {
public:
  string name;  // string: 类成员属性的属性， name: 类成员属性名称
  int weight;

  bool setName(string n){ // `bool`（类成员方法的返回值）`setName`(类成员方法的名称)(`string` （参数类型） `n`（参数名称）)
      name = n;
      return true;
  }
};

关键字 public 确定管理类成员的访问属性，在类对象作用域内，公共成员在类的外部是可访问的，您也可以指定类的成员为 private（私有的）和 protecred（受保护的）

二、C++对象

类提供了对象的蓝图，所以基本上，对象是根据类来创建的，声明类的对象，就像声明基本类型的变量一样，下面的语句声明了类 Dog 的两个对象
1
2
Dog dog1;
Dog dog2;
对象 dog1 和 dog2 都有他们各自的数据成员

三、访问数据成员

类的对象的公共数据成员可以使用直接成员访问运算符.来访问

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


#include <iostream>
#include <string>
#include <stdlib.h>

class Dog {

public:
  string name;
  int weight;

  bool setName(string n){
      name = n;
      return true;
  }

  bool setWeight(int w){
      weight =  w;
      return true;
  }

  string getName(){
      return name;
  }

  int getWeight(){
      return weight;
  }
};

// 主函数
int main() {
    Dog dog1;
    dog1.setName("哈士奇");
    dog1.setWeight(30);
    cout << "狗狗的名字：" << dog1.getName() << " / 体重是：" << dog1.getWeight() << endl;

    Dog dog2;
    dog2.setName("小金毛");
    dog2.setWeight(40);
    cout << "狗狗的名字：" << dog2.getName() << " / 体重是：" << dog2.getWeight() << endl;

    return 0;
}

上面代码被编译和执行时，会产生下列结果：

狗狗的名字：哈士奇/ 体重是：30

狗狗的名字：小金毛/ 体重是：40

【注】私有的成员和受保护的成员不能使用直接成员的访问运算符（.）来直接访问。

四、类成员函数

类成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他函数一样，是类的一个成员，它可以操作类的任意对象，可以访问对象中的所有成员

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <iostream>
#include <string>
#include <stdlib.h>

class Dog {

public:
  string dName;    // 名字
  int dWeight;     // 体重

  string getName(){ // 获取名字
      return dName;
  }
};

也可以在类外面使用 范围解析运算符:: 定义该函数，如下所示：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <iostream>
#include <string>
#include <stdlib.h>

class Dog {

public:
 string dName;     // 名字
 int dWeight;      // 体重
 string getName()  // 获取名字
};

string Dog::getName(){
 return Dog::dName;
}

【注】在::运算符前必须使用类名，调用成员函数是在对象上使用运算符(.),这样它就能操作该对象相关的数据，如下所示：
1
2
Dog dog;
dog.getWeight();

五、类访问修饰符

数据封装是面向对象的一个重要特点，它防止函数直接访问类类型的内部成员，类成员的访问限制是通过在类主题内部对各个区域标记 **public、private、protected**来指定的，关键字 **public、private。protected**称为访问修饰符。一个类可以有多个 public、private、protected 标记区域，每个标识区域在下一个标识区域开始之前或者在遇到类主题结束右括号之前都是有效的。成员和类的默认访问修饰符是 private。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
#include <iostream>
#include <string>
#include <stdlib.h>

class Base{
public:
  // 共有成员

protected:
  // 受保护成员

private:
  // 私有成员
}

5.1、共有（public）成员

共有成员在类的外部是可访问的，可以不使用任何成员函数来设置和获取共有变量的值，如下所示:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


#include <iostream>
#include <string>
#include <stdlib.h>

class Dog {
public:
  string name;
  string getName(void);
  bool setName(string);

};

bool Dog::setName(string n){
  Dog::name = n;
  return true;
}

string Dog::getName() {
  return Dog::name;
}

// 主函数
int main() {

  Dog dog1;
  dog1.setName("哈士奇");
  cout << "狗狗的名字：" << dog1.getName() << endl;

  Dog dog2;
  dog2.setName("小金毛");
  cout << "狗狗的名字：" << dog2.getName() << endl;

  return 0;
}

5.2、私有（private）成员

私有成员变量或函数在类的外部是不可访问的，甚至是不可查的，只有类和有元函数可以访问私有成员，默认情况下，类的所有成员都是私有的，例如在下面的类中，width 是一个私有成员，这意味着，如果您没有使用任何访问修饰符，类的成员将被假定为私有成员：
1
2
3
4
5
6
7
class Dog {
string name;
public:
   int weight;
   bool setName(string n);
   string getName(void);
}

5.3、受保护（protected）成员

受保护成员变量或函数与私有成员相似，但又一点不同，protected 成员在派生类（即子类）中是可以访问的

5.4、继承中的特点

有 public,protected,private 三种继承方式，他们响应的改变了基类成员的访问属性

public 继承：基类 public 成员，protected 成员，private 成员的访问属性分别变成：public，protected，private

protected 继承：基于 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：protected, protected, private

private 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：private, private, private

但无论哪种继承方式，上面两点都没有改变：

private 成员只能被本类成员（类内）和友元访问，不能被派生类访问；

protected 成员可以被派生类访问。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class Shape{
public:
   void setWidth(int w){
       width = w;
   }

   void setHeight(int h){
       height = h;
   }

protected:
   int width;
   int height;
};

// 派生类
class Rectangle: public Shape{
   public:
   int getArea(){
       return (width * height);
   }
};


// 主函数
int main() {

   Rectangle Rect;
   Rect.setWidth(5);
   Rect.setHeight(7);
   // 输出面积
   cout << "Total Area:" << Rect.getArea() << endl;
   return 0;
}

执行结果为：

Total Area:35