C++语言学习（三）——封装（Encapsulation）

时间  2019-11-05
标签 c++ 语言 学习 封装 encapsulation 栏目 C&C++ 繁體版
原文   原文链接

C++语言学习（三）——封装（Encapsulation）

1、封装简介

C语言等面向过程编程中，数据以及数据的相关操做函数都是分离的独立个体；在C++等面向对象编程中，数据以及数据的相关操做被设计为对象，对象包括属性（数据）和操做（函数），二者共同构成对象实体（即类实体）。面向对象编程使程序更模块化，更易读易写，提高了代码重用到一个更高的层次。
面向对象编程中，数据和数据的操做封装为了对象。封装能够隐藏实现细节，使得代码模块化，是把过程和数据包围起来，对数据的访问只能经过已定义的接口。
封装是一种对外提供服务的模型，封装模型是对世间万物的个体抽象。
封装的访问属性以下：
访问属性 属性 对象内部 对象外部
public 公有 可访问 可访问
protected 保护 可访问 不可访问
private 私有 可访问 不可访问
C语言中，struct中全部行为和属性都是public的(默认)，既可使用接口，又能够直接访问其内部数据，没有屏蔽内部数据。
C++语言中，强化了C语言的封装特性，struct、class能够指定行为和属性的访问方式，对内开放数据，对外屏蔽数据，对外提供接口。ios

2、C语言的封装

C语言中，一般使用模块化进行封装。
stack的C语言实现：编程

#include <stdio.h>
#include <string.h>

typedef struct stack
{
    char space[1024];
    int top;
}stack;

void stack_init(stack *st)
{
    st->top = 0;
    memset(&st->space, 0, sizeof(st->space));
}

int is_empty(stack *st)
{
    return st->top == 0;
}
int is_full(stack *st)
{
    return st->top == 1024;
}

char pop(stack *st)
{
    return st->space[--st->top];
}

void push(stack *st, char c)
{
    st->space[st->top++] = c;
}

int main(void)
{
    stack st;
    stack_init(&st);
    unsigned int i;
    for(i = 'a'; i < ('z' + 1); i++)
    {
        if(!is_full(&st))
            push(&st, i);
    }
    for(i = 'a'; i < ('z' + 1); i++)
    {
        printf("%c\n", pop(&st));
    }
    return 0;
}

C语言中封装的struct的数据成员是能够被外部调用修改的。ide

3、C++语言的封装

一、C++语言的封装

C++语言强化了C语言的封装，在类的表示法中定义了属性和行为的访问级别。
C++语言中，用于表示类属性的变量为成员变量；用于表示类行为的函数为成员函数。C++语言中，能够对类的成员变量和成员函数定义访问级别。
public：使用public关键字声明的类的成员变量和成员函数能够在类的内部和外部访问与调用
private：使用private关键字声明的类的成员变量和成员函数只能在类的内部访问和调用
protected：使用protected关键字声明的类的成员变量和成员函数只能在本类以及派生子类的内部访问和调用。
类的成员的做用域只在类的内部，外部不能直接访问。类的成员函数能够直接访问成员变量和调用成员函数。类的外部能够经过类对象访问public成员。
C++语言中，struct定义的类中成员的默认访问权限为public，class定义的类中成员的默认访问权限为private。模块化

二、C++语言的struct

C++语言中，对struct关键字进行了扩展，struct已经不仅是C语言中变量集合的struct，C++语言中的struct不只能够定义成员函数，也能够实现继承和多态。与C语言中的struct同样，C++语言中使用struct定义类时，成员的默认访问级别为public。函数

#include <iostream>

using namespace std;

struct Person
{
    const char* name;
    int age;
    virtual void print()
    {
        printf("My name is %s, I'm is %d years old.\n",name,age);
    }
};
//默认继承访问权限为public
struct Student : Person
{
    void print()
    {
        printf("My name is %s, I'm is %d years old."
               "My score is %d\n",name,age,score);
    }
    void setScore(const int n)
    {
        score = n;
    }
private:
    int score;
};

int main(int argc, char *argv[])
{
    Person p;
    p.name = "Bob";
    p.age = 30;
    p.print();
    Student s;
    s.name = "Bauer";
    s.age = 20;
    s.setScore(98);
    s.print();
    dynamic_cast<Person*>(&s)->print();
    return 0;
}

三、C++语言的class

因为C++语言的struct须要兼容C语言的struct，C++语言使用新的class关键字定义类。使用class定义类时，成员的默认访问级别为private。
C++中的类支持声明和实现的分离，将类的定义和实现分开，一般.h头文件中只有类的声明，包括成员变量和成员函数的声明；.cpp源文件中完成类的成员函数的实现。学习

#include <iostream>

using namespace std;

class Person
{
public:
    const char* name;
    int age;
    virtual void print()
    {
        printf("My name is %s, I'm is %d years old.\n",name,age);
    }
};

class Student : public Person
{
public:
    void print()
    {
        printf("My name is %s, I'm is %d years old."
               "My score is %d\n",name,age,score);
    }
    void setScore(const int n)
    {
        score = n;
    }
private:
    int score;
};

int main(int argc, char *argv[])
{
    Person p;
    p.name = "Bob";
    p.age = 30;
    p.print();
    Student s;
    s.name = "Bauer";
    s.age = 20;
    s.setScore(98);
    s.print();
    dynamic_cast<Person*>(&s)->print();
    return 0;
}

四、C++语言struct与class的区别

C++语言中struct与class最本质的区别以下：
A、默认访问权限不一样。struct默认的访问权限是public的，class默认的访问权限是private的。
B、默认继承访问权限不一样。struct默认的继承访问权限是public的，class默认的继承访问权限是private的。
C、class可用做定义模板参数的关键字，而struct不能够。
C++语言中，继承时若是没有指定继承访问权限，默认继承访问权限是public继承仍是private继承，取决于子类而不是基类。struct能够继承class，class也能够继承struct，默认的继承访问权限取决于子类是struct仍是class，若是子类使用struct声明，默认继承访问权限是public；若是子类使用class声明，默认继承访问权限是private。spa

#include <iostream>

using namespace std;

class Person
{
public:
    const char* name;
    int age;
    virtual void print()
    {
        printf("My name is %s, I'm is %d years old.\n",name,age);
    }
};
//默认继承访问权限为public
struct Student : public Person
{
public:
    void print()
    {
        printf("My name is %s, I'm is %d years old."
               "My score is %d\n",name,age,score);
    }
    void setScore(const int n)
    {
        score = n;
    }
private:
    int score;
};

int main(int argc, char *argv[])
{
    Person p;
    p.name = "Bob";
    p.age = 30;
    p.print();
    Student s;
    s.name = "Bauer";
    s.age = 20;
    s.setScore(98);
    s.print();
    dynamic_cast<Person*>(&s)->print();
    return 0;
}

五、C++语言封装示例

C++类实现stack：
stack.h源码:设计

#ifndef STACK_H
#define STACK_H

class stack
{
public:
    stack();
    bool is_empty();
    bool is_full();
    void push(char c);
    char pop();
private:
    char space[1024];
    unsigned int top;
};

#endif // STACK_H

stack.cpp源码：code

#include "stack.h"
#include <string.h>

stack::stack()
{
    top = 0;
    memset(space, 0, sizeof(space));
}

bool stack::is_empty()
{
    return top == 0;
}

bool stack::is_full()
{
    return top == 1024;
}

void stack::push(char c)
{
    space[top++] = c;
}

char stack::pop()
{
    return space[--top];
}

main.cpp源码：对象

#include <iostream>
#include "stack.h"
#include <string.h>
using namespace std;

int main()
{
    stack st;
    unsigned int i;
    for(i = 'a'; i < 'z' + 1; i++)
    {
        if(!st.is_full())
            st.push(i);
    }
    for(i = 'a'; i < 'z' + 1; i++)
    {
        cout<<st.pop()<<endl;
    }
    return 0;
}

C++语言中封装的class stack中数据成员是private的，对于外部不可访问，经过设置数据成员和操做方法的访问权限，能够对外部开放、屏蔽数据成员和操做方法。C++经过定义类成员的访问级别实现封装机制。C++语言中类支持声明和实现的分离，在头文件中声明类，在源文件中实现类。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程