当前位置 : 主页 > 编程语言 > 其它开发 >

【OOP】封装:类与对象

来源:互联网 收集:自由互联 发布时间:2022-06-04
OOP封装:介绍了【类与对象】的概念,也介绍了其他相关的知识,如:【内联函数】、【函数重载】、【this指针】等。 目录 引言 类 对象 类的成员 A)成员访问权限 B)成员变量 i. a
OOP封装:介绍了【类与对象】的概念,也介绍了其他相关的知识,如:【内联函数】、【函数重载】、【this指针】等。

目录
  • 引言
  • 类 & 对象
  • 类的成员
    • A)成员访问权限
    • B)成员变量
      • i. auto
      • ii. decltype
    • C)成员函数
  • 补充知识
    • 1. 内联函数
    • 2. 函数重载
    • 3. this 指针


引言

面向对象程序设计(OOP),最核心的概念就是 “对象” 。

简单地说,数据 + 函数 = 对象。

将一组数据和相关的函数结合起来,构成一个结合体,就是封装的过程。

回到顶部


类 & 对象

类(class)是一种用户自定义的类型,包含了数据函数

  • 类中的数据 = 成员变量

    • 在类内定义
  • 类中的函数 = 成员函数

    • 在类内声明
    • 可以在类内 / 类外实现
    class Person {                        // 自定义的类
    public:
        string name;                      // 成员变量
        
        void get_name () {                // 成员函数
            cout << "Name: " << name;
        }
    }
    
  • 定义了类后,将类当成一个数据类型,去定义一个变量,这个变量就是类的对象

    class Person {
        ......
    }
    
    Person a;                    // a 是 Person 类的对象
    a.name = "Karry";            // 使用对象的成员变量的方法
    a.get_name();                // 调用对象的成员函数的方法
    

回到顶部

通常,为了方便管理,我们会将不同的类放在不同的头文件和实现文件里:

  • 头文件:成员变量、成员函数的声明

    // 头文件 Person.h
    #fndef PERSON
    #define PERSON
    
    class Person {
        ......
    }
    
    #endif
    
  • 实现文件:部分成员函数的实现

    // 实现文件 Person.cpp
    #include "Person.h"
    
    ...... // 部分函数实现
    

回到顶部


类的成员

类中的成员主要有:成员变量、成员函数

A)成员访问权限

访问权限分成三种等级:public、private 和 protected。

这里不详细说明三者的性质,只需简单理解,

public 的成员是可以在类外访问的,但是 private 的成员只能在类内访问

class Person {
    int age;           // 默认的访问权限为 private
    
public:
    string name;       // public 访问权限
}

int main() {
    Person a;
    a.name = "Karry";  // name 是 public 的成员变量,可以在类外访问
    // a.age = 23;     // age 是 private 的成员变量,没有权限在类外访问
}

回到顶部


B)成员变量

成员变量的声明方式和普通的变量相同。

除了常见的数据类型,如:intfloatchar 等,还有 autodecltype

以下为 autodecltype 的介绍,可适用于成员变量、成员函数、普通变量、普通函数等。

i. auto

特点:

  • 必须在编译期确定类型
  • 编译器会根据上下文自动确定变量的类型

使用的注意事项:

  • 定义的同时进行初始化

  • 如果是用来定义一连串的数据,这些数据必须为同样的数据类型

  • 可用于:定义变量(尤其是复杂的类型)、追踪函数的返回类型

    // 定义变量
    auto num = 21;
    auto a = "Karry", b = "Wang";
    
    // 追踪函数的返回类型
    auto func(int a, int b) -> int {
        return a + b;
    }
    
  • 不可用于:函数的参数

回到顶部

ii. decltype

特点:

  • 可以对变量 / 表达式的类型进行推导

    struct {
        string name;
        int id;
    } student;
    
    int main() {
        decltype(student) x;        // 推导出 student 的类型,再用类型定义 x
    }
    

使用的方法:

  • 结合 autodecltype ,可以自动追踪函数的返回类型

    auto func(int a, int b) -> decltype(a + b) {
        return a + b;
    }
    
    auto a = func(6, 9);
    

回到顶部


C)成员函数

成员函数的实现方式有:类内实现 / 类外实现

class Person {
public:
    string name;
    
    // 方法1:类内实现
    void get_name() {
        cout << "Name: " << name << endl;
    }
}

// 方法2:类外实现
void Person::get_name() {
    cout << "Name: " << name << endl;
}

定义在类内的成员函数,会被默认为内联函数,因此大多数情况下,我们会将类的实现和声明分开,便于管理。

有关内联函数的更多说明可以在后文的 “补充知识“ 中找到。

关于成员函数,有一些延伸的知识,可以点击后方链接,跳转到相关部分,如:

  1. 如果需要用到若干个同名但是功能不同的函数,应该怎么处理?[函数重载]
  2. 成员函数是如何使用成员变量的?[this 指针]

回到顶部


补充知识

1. 内联函数

内联函数(inline function)是一种特别的函数,可以在调用函数的地方生成与函数等价的表达式。例:

inline int min(int a, int b) {
    return a < b ? a : b;
}

cout << min(2, 5) << endl;

以上代码等价于:

cout << (a < b ? a : b) << endl;

简单地说,内联函数就是将函数的实现直接 ”植入“ 我们调用函数的地方。

虽然,类似的,我们也可以用宏定义(define)来实现这个功能,但是内联函数和宏定义有着一定的区别。

内联函数(inline) 宏定义(define) 操作 在函数调用的地方生成等价的表达式 将宏定义的代码直接拷贝到目的地 功能 可以进行调试、执行检查 - 安全 不容易出错 容易出错

使用内联函数的注意事项:

  1. 内联函数的声明和实现不可以分开
  2. 如果函数包含大段代码 / 循环 / 复杂结构,避免使用内联函数
  3. 编译器有决定权,内联修饰符只是一个建议:
    • 如果函数不值得内联,就会忽略内联修饰符
    • 如果觉得一些函数需要内联,会将其自行转换为内联函数
  4. 定义在类内的成员函数都被默认为内联函数
    • 构造函数、析构函数通常都是内联函数
    • 大段 / 复杂的成员函数建议进行类外定义

回到顶部


2. 函数重载

函数重载:若干个函数有着同样的函数名(大概率功能是相似的),但是处理的数据信息不同。

使用函数重载需要注意的事项:

  1. 函数的参数类型 / 数量需要有变化

  2. 函数的返回类型 / 函数参数的名称不能作为函数重载的区分标识

  3. 如果函数参数有使用缺省值,要避免出现二义性

    缺省值是函数参数中的默认值,例:

    void print_num(int input = 2) {
        cout << "The number is " << input << endl;
    }
    
    print_num(5);    // The number is 5
    print_num();     // The number is 2
    

    使用缺省值时要注意,把参数是缺省值的都往后放,避免混淆。

    如果函数参数内有缺省值时,要注意避免二义性的使用,例:

    void func(int a, int b = 1) {
        cout << "The sum is " << a + b << endl;
    }
    
    void func(int a) {
        cout << "The number is " << a << endl;
    }
    
    int main() {
        //func(5);     // 这种情况下会导致函数重载失败,无法区分两个函数的使用
        
        return 0;
    }
    

函数重载调用时的操作:

  1. 会优先调用类型匹配的函数,例:int 的数据就优先用 int 参数的函数 ......

  2. 如果没有类型匹配的函数,会进行内置类型转换,例:int 的转去 float ......

    void print_num(int a) {
        cout << "The number is " << a << endl;
    }
    
    print_num(5.2);    // 会进行类型转换,输出 The number is 5
    

回到顶部


3. this 指针

类的成员函数,和普通的函数不同的是,它们可以使用类的成员变量。

这是因为,所有成员函数的参数中都有一个隐藏的指针变量 this ,指向当前对象,例:

void Person::get_name() {
    cout << "The person name is " << this->name << endl;
}

回到顶部


上一篇:Kafka 主题解析
下一篇:没有了
网友评论