深入探索C++中的类与对象

简介: 深入探索C++中的类与对象

C++编程语言中,类和对象是面向对象编程(OOP)的核心概念。类定义了一种对象的类型,它描述了该类型对象所应具有的属性和行为;而对象则是根据类创建的具体实例。通过类和对象,C++程序员能够构建出模块化、可重用的代码,提高软件开发的效率和质量。

一、类的定义

C++中,类是通过class关键字定义的。一个类可以包含数据成员(属性)和成员函数(方法)。数据成员存储与对象相关联的数据,而成员函数则定义了对象的行为。

  class MyClass { 
  public: 
  // 数据成员(属性) 
  int myData; 
  
  // 成员函数(方法) 
  MyClass(int value) : myData(value) {} // 构造函数 
  void display() const { std::cout << "Data: " << myData << std::endl; } 
  // ... 其他成员函数 
  };

二、对象的创建与使用

通过类定义,我们可以创建该类的对象。对象的创建是通过类名后跟一对圆括号(对于带有参数的构造函数)或不带圆括号(对于默认构造函数)来完成的。

  int main() { 
  // 创建对象 
  MyClass obj1(10); // 使用带参数的构造函数 
  MyClass obj2; // 使用默认构造函数(如果定义了) 
  
  // 使用对象 
  obj1.display(); // 输出:Data: 10 
  obj2.myData = 20; // 直接访问对象的数据成员 
  obj2.display(); // 输出:Data(假设默认构造函数初始化为0):Data: 20 
  
  return 0; 
  }

三、访问控制

C++中的类支持三种访问控制修饰符:publicprotectedprivatepublic成员可以在任何地方被访问;protected成员在派生类(即子类)中可以被访问,但在类外部不可直接访问;private成员仅能在类内部被访问。

  class AccessControl { 
  private: 
  int privateData; 
  protected: 
  int protectedData; 
  public: 
  int publicData; 
  // ... 成员函数 
  };

四、继

C++支持单继承和多继承。通过继承,一个类(派生类)可以获取另一个类(基类)的属性和行为。这提供了一种代码重用和扩展的方式。

  class Base { 
  public: 
  void baseFunc() { std::cout << "Base function." << std::endl; } 
  }; 
  
  class Derived : public Base { // 继承自Base类 
  public: 
  void derivedFunc() { std::cout << "Derived function." << std::endl; } 
  }; 
  
  int main() { 
  Derived obj; 
  obj.baseFunc(); // 调用基类函数 
  obj.derivedFunc(); // 调用派生类函数 
  return 0; 
  }

五、多态性

多态性是面向对象编程的三大特性之一,它允许使用父类类型的指针或引用来指向子类对象,并通过该指针或引用来调用子类中重写的虚函数。这实现了运行时动态绑定,增强了程序的灵活性和可扩展性。

  class Shape { 
  public: 
  virtual void draw() const { std::cout << "Drawing a generic shape." << std::endl; } 
  virtual ~Shape() {} // 虚析构函数 
  }; 
  
  class Circle : public Shape { 
  public: 
  void draw() const override { std::cout << "Drawing a circle." << std::endl; } 
  }; 
  
  void drawShapes(Shape* shapes[], int n) { 
  for (int i = 0; i < n; ++i) { 
  shapes[i]->draw(); // 动态绑定到正确的draw()函数 
  } 
  } 
  
  int main() { 
  Shape* shapes[2] = {new Circle(), new Shape()}; 
  drawShapes(shapes, 2); // 输出:Drawing a circle. 和 Drawing a generic shape. 
  // ... 释放内存 
  return 0; 
  }

六、封

封装是面向对象编程的四大基本特性之一(另外三个是继承、多态和抽象)。封装的主要目的是保护对象的内部状态(属性),同时提供公共接口(方法)来访问或修改这些状态。封装隐藏了类的内部实现细节,只允许通过对象的方法对数据进行访问和操作,从而提高了数据的安全性和代码的可维护性。

C++中,封装主要通过类的访问控制修饰符(publicprotectedprivate)来实现。private成员只能在类内部被访问,而public成员则可以在任何地方被访问。protected成员在类内部和派生类中可以访问,但在类外部不可直接访问。

  class EncapsulatedClass { 
  private: 
  int privateMember; // 私有成员,只能在类内部访问 
  
  public: 
  EncapsulatedClass(int value) : privateMember(value) {} // 构造函数,初始化私有成员 
  
  // 公共接口,用于访问或修改私有成员 
  int getPrivateMember() const { return privateMember; } 
  void setPrivateMember(int value) { privateMember = value; } 
  }; 
  
  int main() { 
  EncapsulatedClass obj(10); // 创建对象,通过构造函数初始化私有成员 
  std::cout << obj.getPrivateMember() << std::endl; // 访问私有成员,输出:10 
  obj.setPrivateMember(20); // 修改私有成员 
  std::cout << obj.getPrivateMember() << std::endl; // 访问私有成员,输出:20 
  return 0; 
  }

七、友

C++中,有时需要让某个类或函数能够访问另一个类的私有或保护成员。为此,可以使用友元(friend)声明。被声明为友元的类或函数可以访问该类的所有成员,包括私有和保护成员。

  class MyClass { 
  private: 
  int secretData; 
  
  public: 
  MyClass(int data) : secretData(data) {} 
  
  // 声明另一个类为友元 
  friend class FriendClass; 
  
  // 声明一个函数为友元 
  friend void friendFunction(MyClass& obj); 
  }; 
  
  class FriendClass { 
  public: 
  void displaySecret(const MyClass& obj) { 
  std::cout << "Secret data: " << obj.secretData << std::endl; // 可以访问私有成员 
  } 
  }; 
  
  void friendFunction(MyClass& obj) { 
  std::cout << "Secret data: " << obj.secretData << std::endl; // 可以访问私有成员 
  } 
  
  int main() { 
  MyClass obj(42); 
  FriendClass friendObj; 
  friendObj.displaySecret(obj); // 输出:Secret data: 42 
  friendFunction(obj); // 输出:Secret data: 42 
  return 0; 
  }

八、构造函数与析构函数

构造函数用于初始化对象的状态,它在创建对象时自动调用。析构函数用于释放对象所使用的资源,它在对象生命周期结束时自动调用。C++支持多种类型的构造函数,包括默认构造函数、带参数的构造函数、拷贝构造函数和移动构造函数。

  class MyClass { 
  private: 
  int* data; 
  
  public: 
  // 默认构造函数 
  MyClass() : data(nullptr) {} 
  
  // 带参数的构造函数 
  MyClass(int value) : data(new int(value)) {} 
  
  // 拷贝构造函数 
  MyClass(const MyClass& other) : data(new int(*other.data)) {} 
  
  // 移动构造函数(C++11及以后) 
  MyClass(MyClass&& other) noexcept : data(other.data) { 
  other.data = nullptr; 
  } 
  
  // 析构函数 
  ~MyClass() { 
  delete data; // 释放内存 
  } 
  
  // ... 其他成员函数 
  };

九、运算符重载

C++允许程序员重新定义或重载大部分内置运算符,以便它们能用于自定义类型。通过运算符重载,可以使自定义类型的使用更加自然和直观。

  class Complex { 
  private: 
  double real, imag; 
  
  public: 
  // ... 构造函数、析构函数和其他成员函数 
  
  // 运算符重载:+ 
  Complex operator+(const Complex& other) const { 
  return Complex(real + other.real, imag + other.imag); 
  } 
  
  // ... 其他运算符重载,如-、*、/、==等 
  }; 
  
  int main() { 
  Complex c1(
  Complex c1(1.0, 2.0); 
  Complex c2(3.0, 4.0); 
  Complex c3 = c1 + c2; // 使用重载的+运算符 
  
  std::cout << "c3 = " << c3.real << " + " << c3.imag << "i" << std::endl; // 输出:c3 = 4 + 6i 
  
  return 0; 
  }

十、继

继承是面向对象编程中的一个重要概念,它允许我们定义一个类(称为基类或父类)作为另一个类(称为派生类或子类)的基础,从而创建一个类层次结构。派生类继承基类的所有公共和保护成员,并可以添加自己的新成员。

  class Base { 
  public: 
  void display() { 
  std::cout << "This is the base class." << std::endl; 
  } 
  }; 
  
  class Derived : public Base { // 继承自Base类 
  public: 
  void anotherDisplay() { 
  std::cout << "This is the derived class." << std::endl; 
  } 
  }; 
  
  int main() { 
  Derived obj; // 创建Derived类的对象 
  obj.display(); // 调用继承自Base类的display方法 
  obj.anotherDisplay(); // 调用Derived类自己的anotherDisplay方法 
  return 0; 
  }

十一、多态

多态是面向对象编程中的一个重要概念,它允许使用父类类型的引用或指针来调用子类的方法。在运行时,程序将根据实际对象的类型来决定调用哪个方法,从而实现不同的行为。这主要通过虚函数和纯虚函数来实现。

  class Shape { 
  public: 
  virtual void draw() { // 虚函数 
  std::cout << "Drawing a generic shape." << std::endl; 
  } 
  }; 
  
  class Circle : public Shape { 
  public: 
  void draw() override { // 重写虚函数 
  std::cout << "Drawing a circle." << std::endl; 
  } 
  }; 
  
  int main() { 
  Shape* shapePtr; // 指向Shape的指针 
  
  Circle circle; // Circle类的对象 
  shapePtr = &circle; // 让指针指向Circle对象 
  
  shapePtr->draw(); // 调用Circle类的draw方法,因为shapePtr实际指向的是Circle对象 
  return 0; 
  }

在上面的例子中,draw方法在Shape类中被声明为virtual,这意味着它可以在派生类中被重写。在main函数中,我们通过指向Shape的指针shapePtr调用了draw方法,但由于shapePtr实际上指向的是Circle对象,所以调用的是Circle类的draw方法,这就是多态的体现。

注意:多态的实现需要满足一定的条件,包括存在继承关系、基类中有虚函数、通过基类指针或引用调用虚函数等。

相关文章
|
3天前
|
编译器 C++
【C++初阶】—— 类和对象 (下)
【C++初阶】—— 类和对象 (下)
7 2
|
3天前
|
存储 编译器 C++
【C++初阶】—— 类和对象 (中)
【C++初阶】—— 类和对象 (中)
10 3
|
3天前
|
存储 编译器 C语言
【C++初阶】—— 类和对象 (上)
【C++初阶】—— 类和对象 (上)
9 1
|
3天前
|
算法 编译器 C++
Essential C++第4章 基于对象的编程风格
Essential C++第4章 基于对象的编程风格
|
4天前
|
程序员 C语言 C++
【C++语言】继承:类特性的扩展,重要的类复用!
【C++语言】继承:类特性的扩展,重要的类复用!
|
4天前
|
C++ 容器
【C++语言】String 类关键函数实现,手搓一个简单字符串类!
【C++语言】String 类关键函数实现,手搓一个简单字符串类!
|
4天前
|
C++ 容器 存储
【C++语言】想学STL,先细细拿捏string类,万字详解string类 (内附精美思维导图)
【C++语言】想学STL,先细细拿捏string类,万字详解string类 (内附精美思维导图)
|
4天前
|
C++ 编译器
【C++语言】Date类的代码实现(操作符重载运用)
【C++语言】Date类的代码实现(操作符重载运用)
|
4天前
|
C++
【C++语言】类和对象(下)
【C++语言】类和对象(下)
|
4天前
|
编译器 数据安全/隐私保护 C++
c++primer plus 6 读书笔记 第十三章 类继承
c++primer plus 6 读书笔记 第十三章 类继承

热门文章

最新文章