ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

【OOP】封装:类与对象

2022-06-03 10:03:44  阅读:49  来源: 互联网

标签:封装 函数 对象 成员 name int OOP 内联 变量


目录


引言

面向对象程序设计(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;
}

回到顶部


标签:封装,函数,对象,成员,name,int,OOP,内联,变量
来源: https://www.cnblogs.com/bljw-02/p/16339575.html

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有