【C++面向对象】1. 类、对象

文章目录

  • [【 1. 类 & 对象的定义 】](#【 1. 类 & 对象的定义 】)

    • [1.1 类的定义](#1.1 类的定义)
    • [1.2 对象的定义](#1.2 对象的定义)
  • [【 2. 类的成员 】](#【 2. 类的成员 】)

  • [【 3. 类的访问修饰符 】](#【 3. 类的访问修饰符 】)

    • [3.1 public 公有成员](#3.1 public 公有成员)
    • [3.2 private 私有成员](#3.2 private 私有成员)
    • [3.3 protected 保护成员](#3.3 protected 保护成员)
    • [3.4 继承中的访问修饰符特点](#3.4 继承中的访问修饰符特点)
  • C++ 在 C 语言的基础上增加了面向对象编程,C++ 支持面向对象程序设计。 是 C++面向对象 的核心特性,通常被称为用户定义的类型。

  • 类用于指定对象的形式,它包含了 数据表示法 和用于处理数据的 方法 。类中的数据和方法称为类的 成员。函数在一个类中被称为类的成员。

【 1. 类 & 对象的定义 】

1.1 类的定义

  • 定义一个类,本质上是定义一个数据类型的蓝图。这实际上并没有定义任何数据,但它定义了类的名称意味着什么,也就是说,它定义了类的对象包括了什么,以及可以在这个对象上执行哪些操作。
  • 类定义是以关键字 class 开头,后跟类的名称。类的主体是包含在一对花括号中,类定义后必须跟着一个分号或一个声明列表。例如,我们使用关键字 class 定义 Box 数据类型,如下所示:
cpp 复制代码
class Box
{
   public:
      double length;   // 盒子的长度
      double breadth;  // 盒子的宽度
      double height;   // 盒子的高度
};
  • 关键字 public 确定了类成员的访问属性。 在类对象作用域内,public 公共成员在类的外部是可访问的 。您也可以指定类的成员为 private 或 protected,这个我们稍后会进行讲解。

1.2 对象的定义

  • 类提供了对象的蓝图,所以基本上,对象是根据类来创建的。声明类的对象,就像声明基本类型的变量一样。下面的语句声明了类 Box 的两个对象,对象 Box1 和 Box2 都有它们各自的数据成员:
cpp 复制代码
Box Box1;          // 声明 Box1,类型为 Box
Box Box2;          // 声明 Box2,类型为 Box

【 2. 类的成员 】

2.1 数据成员

  • 类的对象的公共数据成员可以使用直接成员访问运算符即小数点 . 来访问。私有的成员和受保护的成员不能使用直接成员访问运算符 . 来直接访问。
  • 实例:
cpp 复制代码
#include <iostream>

using namespace std;

class Box
{
   public:
      double length;   // 长度
      double breadth;  // 宽度
      double height;   // 高度
};

int main( )
{
   Box Box1;        // 声明 Box1,类型为 Box
   Box Box2;        // 声明 Box2,类型为 Box
   double volume = 0.0;     // 用于存储体积

   // box 1 详述
   Box1.height = 5.0; 
   Box1.length = 6.0; 
   Box1.breadth = 7.0;

   // box 2 详述
   Box2.height = 10.0;
   Box2.length = 12.0;
   Box2.breadth = 13.0;

   // box 1 的体积
   volume = Box1.height * Box1.length * Box1.breadth;
   cout << "Box1 的体积:" << volume <<endl;

   // box 2 的体积
   volume = Box2.height * Box2.length * Box2.breadth;
   cout << "Box2 的体积:" << volume <<endl;
   return 0;
}

2.2 成员函数

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

类的内部定义成员函数

  • 在类定义中定义的成员函数默认把函数声明为 内联 的 ,可以不使用 inline 标识符
  • 实例,在 Box类 的内部定义 getVolume() 函数:
cpp 复制代码
class Box
{
   public:
      double length;      // 长度
      double breadth;     // 宽度
      double height;      // 高度

      double getVolume(void)
      {
         return length * breadth * height;
      }
};

类的外部定义成员函数

  • 在类的外部使用 范围解析运算符 :: 定义成员函数,在 :: 运算符之前必须使用类名。
  • 实例:在 Box类 的外部定义 getVolume() 函数
cpp 复制代码
double Box::getVolume(void)
{
    return length * breadth * height;
}

成员函数的访问

  • 调用成员函数是在对象上使用点运算符(.),这样它就能操作与该对象相关的数据,
  • 实例
cpp 复制代码
Box myBox;          // 创建一个对象

myBox.getVolume();  // 调用该对象的成员函数

实例

cpp 复制代码
#include <iostream>

using namespace std;

class Box
{
   public:
      double length;         // 长度
      double breadth;        // 宽度
      double height;         // 高度

      // 成员函数声明
      double getVolume(void);
      void setLength( double len );
      void setBreadth( double bre );
      void setHeight( double hei )
      {
    		height = hei;
	  }
};

// 成员函数定义
double Box::getVolume(void)
{
    return length * breadth * height;
}

void Box::setLength( double len )
{
    length = len;
}

void Box::setBreadth( double bre )
{
    breadth = bre;
}


// 程序的主函数
int main( )
{
   Box Box1;                // 声明 Box1,类型为 Box
   double volume = 0.0;     // 用于存储体积

   // box 1 详述
   Box1.setLength(6.0); 
   Box1.setBreadth(7.0); 
   Box1.setHeight(5.0);

   // box 1 的体积
   volume = Box1.getVolume();
   cout << "Box1 的体积:" << volume <<endl;

   return 0;
}

【 3. 类的访问修饰符 】

  • 数据封装是面向对象编程的一个重要特点,它防止函数直接访问类类型的内部成员。类成员的 访问限制 是通过在类主体内部对各个区域标记 public、private、protected 来指定的。关键字 public、private、protected 称为访问修饰符。
  • 一个类可以有多个 public、protected 或 private 标记区域。每个标记区域在下一个标记区域开始之前或者在遇到类主体结束右括号之前都是有效的。成员和类的 默认访问修饰符是 private
  • 实例
cpp 复制代码
class Base {

   public:

  // 公有成员

   protected:

  // 受保护成员

   private:

  // 私有成员

};

3.1 public 公有成员

  • 公有成员在程序中类的外部是可访问的。我们可以不使用任何成员函数来 直接设置和获取公有变量的值。
  • 实例:
cpp 复制代码
#include <iostream>

using namespace std;

class Line
{
   public:
      double length;
      void setLength( double len );
      double getLength( void );
};

// 成员函数定义
double Line::getLength(void)
{
    return length ;
}

void Line::setLength( double len )
{
    length = len;
}

// 程序的主函数
int main( )
{
   Line line;

   // 设置长度
   line.setLength(6.0); 
   cout << "Length of line : " << line.getLength() <<endl;

   // 不使用成员函数设置长度
   line.length = 10.0; // OK: 因为 length 是公有的
   cout << "Length of line : " << line.length <<endl;
   return 0;
}

3.2 private 私有成员

  • 私有成员变量或函数在类的外部是不可访问的,甚至是不可查看的。只有类和友元函数可以访问私有成员。

  • 默认情况下(没有使用任何访问修饰符时),类的所有成员都是私有的。如下所示:width 是 私有的。

cpp 复制代码
class Box
{
   double width;
   public:
      double length;
      void setWidth( double wid );
      double getWidth( void );
};
  • 实际操作中,我们 一般会在私有区域定义数据,在公有区域定义相关的函数,以便在类的外部也可以调用这些函数。
cpp 复制代码
#include <iostream>

using namespace std;

class Box
{
   public:
      double length;
      void setWidth( double wid );
      double getWidth( void );

   private:
      double width;
};

// 成员函数定义
double Box::getWidth(void)
{
    return width ;
}

void Box::setWidth( double wid )
{
    width = wid;
}

// 程序的主函数
int main( )
{
   Box box;

   // 不使用成员函数设置长度
   box.length = 10.0; // OK: 因为 length 是公有的
   cout << "Length of box : " << box.length <<endl;

   // 不使用成员函数设置宽度
   // box.width = 10.0; // Error: 因为 width 是私有的
   box.setWidth(10.0);  // 使用成员函数设置宽度
   cout << "Width of box : " << box.getWidth() <<endl;

   return 0;
}

3.3 protected 保护成员

  • 保护成员变量或函数与私有成员十分相似,但有一点不同,即 public 保护成员在派生类(即子类)中是可访问的
  • 实例:从父类 Box 派生了一个子类 smallBox, width 成员可被派生类 smallBox 的任何成员函数访问。
cpp 复制代码
#include <iostream>
using namespace std;

class Box
{
   protected:
      double width;
};

class SmallBox:Box // SmallBox 是派生类
{
   public:
      void setSmallWidth( double wid );
      double getSmallWidth( void );
};

// 子类的成员函数
double SmallBox::getSmallWidth(void)
{
    return width ;
}

void SmallBox::setSmallWidth( double wid )
{
    width = wid;
}

// 程序的主函数
int main( )
{
   SmallBox box;

   // 使用成员函数设置宽度
   box.setSmallWidth(5.0);
   cout << "Width of box : "<< box.getSmallWidth() << endl;

   return 0;
}

3.4 继承中的访问修饰符特点

  • 共有public, protected, private三种继承方式,它们相应地改变了基类成员的访问属性。
基类 成员的访问属性 派生 成员的访问属性
public继承 public → public private → private protected → protected
private 继承 public → private private → private protected → private
protected 继承 public → protected private → private protected → protected
  • 但无论哪种继承方式,有两点都没有改变:
    • private 成员只能被本类成员(类内)和友元访问,不能被派生类访问;
    • protected 成员可以被派生类访问。
相关推荐
懒惰才能让科技进步16 分钟前
从零学习大模型(十二)-----基于梯度的重要性剪枝(Gradient-based Pruning)
人工智能·深度学习·学习·算法·chatgpt·transformer·剪枝
DARLING Zero two♡20 分钟前
关于我、重生到500年前凭借C语言改变世界科技vlog.16——万字详解指针概念及技巧
c语言·开发语言·科技
7年老菜鸡21 分钟前
策略模式(C++)三分钟读懂
c++·qt·策略模式
Gu Gu Study22 分钟前
【用Java学习数据结构系列】泛型上界与通配符上界
java·开发语言
Ni-Guvara30 分钟前
函数对象笔记
c++·算法
似霰34 分钟前
安卓智能指针sp、wp、RefBase浅析
android·c++·binder
芊寻(嵌入式)44 分钟前
C转C++学习笔记--基础知识摘录总结
开发语言·c++·笔记·学习
獨枭1 小时前
C++ 项目中使用 .dll 和 .def 文件的操作指南
c++
霁月风1 小时前
设计模式——观察者模式
c++·观察者模式·设计模式
橘色的喵1 小时前
C++编程:避免因编译优化引发的多线程死锁问题
c++·多线程·memory·死锁·内存屏障·内存栅栏·memory barrier