CPP 学习 - 类和对象

最新推荐文章于 2023-09-12 13:56:32 发布
最新推荐文章于 2023-09-12 13:56:32 发布
阅读量209 收藏 1
点赞数
分类专栏： 基础 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38071960/article/details/112552881
版权

一、类中的默认函数 + this 指针

（一）默认函数 + this 指针

  1. 构造函数

  2. 析构函数

  3. 拷贝构造函数

  4. 赋值运算符函数

    #include <string.h>

class Point
{
public:
    Point(int x, int y);					// 构造函数
    ~Point();								// 析构函数
    Point(const Point &rhs);				// 拷贝构造函数
    Point &operator = (const Point &rhs);	// 赋值运算符函数
    
private:
    char *_contant;
    int _ix;
    int _iy;
}

1. 构造函数

tips：

  1. 初始化列表的赋值顺序应当和成员变量定义顺序相同
  2. 初始化与赋值不同，具体体现在于三种特殊数据成员：常量成员、引用成员、类对象成员

实现代码
Point::Point(char *contant, int x = 0, int y = 0)
    : _contant(new char[strlen(contant + 1)]())
	, _ix(x)
    , _iy(y)
{ 
	strcpy(_contant, contant);
}


2. 析构函数

tips：

  1. 一个类只有唯一一个析构函数，析构函数不能重载

  2. 在堆中创建变量时，不会自动执行析构函数

    指针仍指向堆空间的类成员，所以类未被及时销毁，所以需要手动执行析构函数

  3. 对象的销毁与析构函数不等价

    堆对象，对象销毁时，除了执行析构函数，还需要执行 operator delete(void *)


析构函数调用时机
  1. 对于全局定义的对象，每当程序开始运行，在主函数main接受程序控制权之前，就调用构造函数创建全局对象，整个程序结束时自动调用全局对象的析构函数。
  2. 对于局部定义的对象，每当程序流程到达该对象的定义处就调用构造函数，在程序离开局部对象的作用域时调用对象的析构函数。
  3. 对于关键字static定义的静态局部变量，当程序流程第一次到达该对象定义处调用构造函数，在整个程序结束时调用析构函数。
  4. 对于用new运算符创建的对象，每当创建该对象时调用构造函数，当用delete删除该对象时调用析构函数。

实现代码
Point::~Point()
{
    delete _contant;
    _contant = nullptr;
}


3. 拷贝构造函数

拷贝函数调用时机

  1. 当用一个已经存在的对象初始化另一个新对象时，会调用拷贝构造函数。

    Point pt2 = pt1

  2. 当实参和形参都是对象，进行实参与形参的结合时，会调用拷贝构造函数。

    void func(Point pt) { // 结构体 }

  3. 当函数的返回值是对象，函数调用完成返回时，会调用拷贝构造函数。

    Point func() { // 结构体 }

    编译器会自动优化该返回值，若要实现则通过以下命令进行编译

    ​ g++ [filename].cc -fno-elide-constructors

tips：当类类型中有数组时，需注意浅拷贝和深拷贝


实现代码
#include <string.h>

Point::Point(const Point &rhs)
    : _contant(new char[strlen(rhs.contant) + 1]())
    , _ix(rhs._ix)
    , _iy(rhs._iy)
{
	strcpy(_contant, rhs.contant);	// 深拷贝
}

const Point &rhs中需要注意的事项：

  1. &rhs 中的 &
    由于当创建临时变量时，会调用拷贝构造函数，若不为引用，即直接为 rhs，则在创建实参时，再次执行拷贝构造函数，反复如此，从而导致栈溢出
  2. const
    必须是 const 类型，才能指向右值


4. 赋值运算符函数

步骤：

  1. 自复制
  2. 释放左操作数
  3. 深拷贝（包含空间的申请）
  4. 返回 *this

实现代码
Point &Point::operator=(const Point &rhs)
{
    if(this == &rhs)	// 返回本值时，由于先 delete 成员函数，从而会导致值丢失
        return *this;
    
    delete[] _contant;
    _contant = nullptr;
    
    _contant = new char[strlen(rhs._contant) + 1]();
    strcpy(_contant, rhs._contant);
    
    return *this;
}

tips：

  1. 如果去掉返回类型的 &，那当返回时，返回的为类本身，从而调用一次拷贝构造函数，造成浪费

  2. 如果不返回 Point &，比如返回类型为 void，则当连等时，会异常

    Point pt1, pt2, pt3;
pt3 = pt2 = pt1;	// 若不为 Point &，此处会报错

调用方法
Point pt1, pt2;
pt2 = pt1;
pt2.operator=(pt1);	// 两者等价


5. this 指针

在类中定义的非静态成员函数中都有一个隐含的this指针，它代表的就是当前对象本身，它作为成员函数的第一个参数，由编译器自动补全。

this 指针本身不能修改，是顶层 const / 指针常量 / *const

案例代码
void Point::print(Point * const this) {
    // 结构体
}


还有

移动构造函数

Point(const Point&& rhs); // && 右值引用

移动拷贝函数

Point& operator=(Point&& rhs);

有缘再写！




（二）几种模板 - ？不确定

= delete

  1. 禁止使用编译器默认生成的函数

  2. delete 关键字可用于任何函数，不仅仅局限于类的成员函数

  3. 模板特化：在模板特例化中，可以用delete来过滤一些特定的形参类型



= default

​ 相当于无参的构造函数

参考博客：https://blog.csdn.net/lmb1612977696/article/details/80035487

https://docs.microsoft.com/en-us/cpp/cpp/explicitly-defaulted-and-deleted-functions?view=vs-2019#explicitly-defaulted-functions



= 0

虚函数 ==> 纯虚函数，详情见 - 继承和多态

有缘再写！

学完再改





（三）类中的特殊数据成员

  1. 常量成员
  2. 引用成员
  3. 类对象成员
  4. 静态成员

常量成员、引用成员、类对象成员

tips：必须在构造函数的初始化列表中初始化

引用成员占据一个指针空间大小

类对象成员如果不显示初始化，会调用默认构造函数，若类对象的类类型无默认构造函数，则会报错



静态数据成员

tips：

  1. 静态数据成员在编译时就被创建并初始化
  2. 不能在 [filename].h中定义，会导致多次定义 ——> 必须在 [filename].cc中定义
  3. 静态数据成员不占类的空间

留个坑：
静态成员变量，在类中的声明定义
static const std::string = “xxx”; // 异常！

有缘再改！





（四）类中的特殊成员函数

1. 静态成员函数

静态成员函数的特点

  1. 静态成员函数内部不能使用非静态的数据成员和非静态的成员函数

  2. 静态成员函数内部只能调用静态数据成员和静态的成员函数

    原因：无 this 指针

  3. 可以直接使用类名，来调用静态成员函数

tips：声明时需要加上 static，但是在实现时，不能加 static 修饰



2. const 成员函数

const 成员函数的特点
  1. const 成员函数的 this 指针类型为 const [classname] *const this
  2. 与非 const 成员函数可以进行重载，但 const 成员函数不能修改数据成员
  3. const 对象只能调用 const 成员函数，非 const 成员函数均可调用

定义方法
void point() const;		// 静态成员函数，通常优先写静态成员函数，再写普通成员函数
void point();			// 普通成员函数，非 const 对象优先调用普通成员函数




（五）对象的组织

  1. const 对象
  2. 指向对象的指针
  3. 对象数组
  4. 堆对象

对象数组

代码示例
Point pt1[3] = {Point(1, 2), Point(3, 4)}	// 会有三个对象创建

Point pt2[3] = {{1, 2}, {3, 4}}				// 等价

Point pt2[3] = {(1, 2), (3, 4)}				// 错误
/* 
 * (1, 2) 为逗号表达式，即执行表达式中最后的部分
 * pt2[0] = Point(2, 0);
 * pt2[1] = Point(4, 0);
*/




二、几种设计模式

1. 单例模式

实现代码

// Singleton.h
class Singleton
{
public:
	static Singleton *getInstance()
    {
        if(nullptr == _pInstance)
            _pInstance = new Singleton();
        
        return _pInstance;
    }
    
    static void destory()
    {
        if(_pInstance)
        {
            delete _pInstance;
            _pInstance = nullptr;
        }
    }
    
private:
    static Singleton *_pInstance;
    
    singleton() {}
    ~singleton() {}
}



// Singleton_test.cc 文件
Singleton *Singleton::_pInstance = nullptr;

int main()
{
    Singleton *ps = Singleton::getInstance();
    
    Singleton::destroy();
    
    return 0;
}

单例模式的自动释放

四种释放方法
  1. 以友元的形式
  2. 内部类 + 静态数据成员形式
  3. atexit形式
  4. pthread_once形式

1. 以友元的形式
#include <iostream>

using std::cout;
using std::endl;

class AutoRelease;

class Singleton
{
    // 友元函数，实现自动释放
    friend AutoRelease;

public:
    static Singleton *getInstance()
    {
        if(nullptr == _pInstance)
            _pInstance = new Singleton();

        return _pInstance;
    }

    // 用友元函数替代 destroy()
    /* static void destroy() */
    /* { */
    /*     delete _pInstance; */
    /*     _pInstance = nullptr; */
    /* } */

private:
    Singleton()
    {
        cout << "Singleton()" << endl;
    }

    ~Singleton()
    {
        cout << "~Singleton()" << endl;
    }

    static Singleton *_pInstance;
};

// 饿汉模式和懒汉模式
// 懒汉模式 - 在类加载时，不创建实例，所以类加载速度快，但运行时获取对象的速度慢
// 饿汉模式 - 在类加载时完成初始化，所以类加载慢，但获取对象的速度快
// 在多线程环境，使用懒汉模式可能会导致单例模式的失效
/* Singleton *Singleton::_pInstance = nullptr; // 懒汉模式 */
Singleton *Singleton::_pInstance = getInstance();   // 饿汉模式

class AutoRelease
{
public:
    AutoRelease()
    {
        cout << "AutoRelease()" << endl;
    }

    ~AutoRelease()
    {
        cout << "~AutoRelease()" << endl;

        delete Singleton::_pInstance;
        Singleton::_pInstance = nullptr;
    }
};

int main()
{
    // 创建 Singleton 的单例对象 _pInstance
    Singleton::getInstance();

    // 生成 AutoRelease 对象，其中该友元类在生命周期结束后会自动调用析构函数
    // 在 ~AutoRelease() 中，会销毁单例对象 _pInstance
    AutoRelease ar; // 栈对象

    // 由于第一次 AutoRelease 的析构函数中已经删除单例对象 _pInstance
    // 本次的析构函数中不会再次调用 ~Singleton()
    AutoRelease ar2; // 栈对象

    return 0;
}

/***
 * 运行结果：
 * Singleton()
 * AutoRelease()
 * AutoRelease()
 * ~AutoRelease()
 * ~Singleton()
 * ~AutoRelease()
 */

2. 内部类 + 静态数据成员形式
#include <iostream>

using std::cout;
using std::endl;

class Singleton
{
public:
    static Singleton *getInstance()
    {
        if(nullptr == _pInstance)
            _pInstance = new Singleton();

        return _pInstance;
    }

    /* static void destroy() */
    /* { */
    /*     delete _pInstance; */
    /*     _pInstance = nullptr; */
    /* } */

private:
    Singleton()
    {
        cout << "Singleton()" << endl;
    }

    ~Singleton()
    {
        cout << "~Singleton()" << endl;
    }

    // 内部私有成员
    class AutoRelease
    {
    public:
        AutoRelease()
        {
            cout << "AutoRelease()" << endl;
        }

        ~AutoRelease()
        {
            cout << "~AutoRelease()" << endl;
            delete _pInstance;
            _pInstance = nullptr;
        }
    };

    static Singleton *_pInstance;
    // 内部私有成员
    static AutoRelease _ar;
};

/* Singleton *Singleton::_pInstance = nullptr; // 懒汉模式 */
Singleton *Singleton::_pInstance = getInstance();   // 饿汉模式
// 初始化
Singleton::AutoRelease Singleton::_ar;

int main()
{
    Singleton::getInstance();

    return 0;
}

/***
 * 运算结果：
 * AutoRelease()
 * Singleton()
 * ~AutoRelease()
 * ~Singleton()
 */

3. atexit形式
#include <iostream>                                                               

#include <stdlib.h>

using std::cout;
using std::endl;

// atexit 介绍
// 使用方法：int atexit(void (*function)(void));
// 作用：调用该方法后，在程序正常结束后，调用该函数指针指向的函数
class Singleton
{
public:
    static Singleton *getInstance()
    {   
        if(nullptr == _pInstance)
        {
            _pInstance = new Singleton();
            atexit(destroy);
        }

        return _pInstance;
    }   

    static void destroy()
    {   
        delete _pInstance;
        _pInstance = nullptr;
    }   

private:
    Singleton()
    {   
        cout << "Singleton()" << endl;
    }   

    ~Singleton()
    {   
        cout << "~Singleton()" << endl;
    }   

    static Singleton *_pInstance;
};

/* Singleton *Singleton::_pInstance = nullptr; // 懒汉模式 */
Singleton *Singleton::_pInstance = getInstance();   // 饿汉模式

int main()
{
    Singleton::getInstance();

    return 0;
}

4. pthread_once形式 - Linux 环境
#include <iostream>

#include <pthread.h>
#include <stdlib.h>

using std::cout;
using std::endl;

// pthread_onec 介绍
// 使用方法：int pthread_once(pthread_once_t * once_-control
//                  void (*init_routine)(void));
// 作用：在首次执行 pthread_once 时，会执行 init 函数
//      只有首次运行该函数时，才会执行 init，由宏 PTHREAD_ONCE_INIT 来记录
//      所以，在多线程环境中，pthread_once 依旧可以用懒汉模式初始化变量
// pthread_once 是 POSIX - Linux 下的标准，所以只能在 Linux 系统中使用，跨平台性较差
// 执行时需要加载线程库：
//      g++ Singleton_pthread_once -lpthread
class Singleton
{
public:
    static Singleton *getInstance()
    {   
        pthread_once(&_once, init);

        return _pInstance;
    } 

    static void init()
    {
        _pInstance = new Singleton();
        atexit(destroy);
    }

    static void destroy()
    {   
        delete _pInstance;
        _pInstance = nullptr;
    }   

private:
    Singleton()
    {   
        cout << "Singleton()" << endl;
    }   

    ~Singleton()
    {   
        cout << "~Singleton()" << endl;
    }   

    static Singleton *_pInstance;
    static pthread_once_t _once;
};

Singleton *Singleton::_pInstance = nullptr; // 懒汉模式
pthread_once_t Singleton::_once = PTHREAD_ONCE_INIT; // 宏

int main()
{
    Singleton::getInstance();

    return 0;

}


2. PIMPL 模式 - 编译防火墙

PIMPL（Private Implementation 或 Pointer to Implementation）：通过一个私有的成员指针，将指针所指向的类的内部实现数据进行隐藏。

PIMPL又称作“编译防火墙”，它的视线中就用到了嵌套类。

PIMPL设计模式的优点

  1. 提高编译速度
  2. 实现信息隐藏
  3. 减小编译依赖，可以用最小的代价平滑的升级库文件
  4. 接口与实现进行解耦
  5. 移动语义友好

案例代码

Line.h

#ifndef __LINE_H
#define __LINE_H

class Line
{
public:
    Line(int, int, int, int);
    ~Line();
    void printLine() const;

private:
    // 将 Line 的私有成员的实现封装在 class - LineImpl 中
    class LineImpl;
    LineImpl *_pimpl;
};

#endif // __LINE_H

Line.cc

#include <iostream>

#include "Line.h"

using std::cout;
using std::endl;

// 实现 Line 的私有成员的实现
class Line::LineImpl
{
public:
    // 构造函数
    LineImpl(int x1, int y1, int x2, int y2)
        : _pt1(x1, y1)
        , _pt2(x2, y2)
    {}
    void printLineImpl() const;

private:
    // 私有类
    class Point
    {
    public:
        Point(int x = 0, int y = 0)
            : _x(x), _y(y)
        {}
        void print() const;

    private:
        int _x;
        int _y;
    };

    Point _pt1;
    Point _pt2;
};

void Line::LineImpl::Point::print() const
{
    cout << "(" << _x
         << ", " << _y
         << ")";
}

void Line::LineImpl::printLineImpl() const
{
    _pt1.print();
    cout << " ----> ";
    _pt2.print();
    cout << endl;
}

Line::Line(int x1, int y1, int x2, int y2)
    : _pimpl(new LineImpl(x1, y1, x2, y2))
{}

Line::~Line()
{
    delete _pimpl;
    _pimpl = nullptr;
}

void Line::printLine() const
{
    _pimpl->printLineImpl();
}

Line_test.cc

#include "Line.h"

int main()
{
    Line the_line(1, 2, 3, 4);
    the_line.printLine();

    return 0;
}




三、new 与 delete 表达式

工作步骤

new 表达式工作步骤

  1. 调用名为 operator new 的标准库函数，分配足够大的原始的未类型化的内存，以保存指定类型的一个对象
  2. 运行该类型的一个构造函数初始化对象
  3. 返回指向新分配并构造的构造函数对象的指针`

delete 表达式工作步骤

  1. 调用析构函数，回收对象中数据成员所申请的资源
  2. 调用名为operator delete的标准库函数释放该对象所用的内存

顺序不能调换：operator delete会将从栈空间指向堆空间的指针删除，从而导致析构函数无法 delete


实现代码

// Student.cc
#include <string.h>

class Student
{
public:
    Student(int id, const char *name)	// 构造函数
        :_id(id)
        , _name(new char[strlen(name) + 1]())
    {
        strcpy(_name, name);
    }
    
    ~Student()	// 析构函数
    {
        delete[] _name;
        _name = nullptr;
    }
    
    // 默认为静态函数，所以没有 this 指针
    void *operator new(size_t sz)	// operator new 函数的重载
    {
        // 1. 调用名为 operator new的标准库函数
        // 分配足够大的原始的未类型化的内存，以保存指定类型的一个对象
        void *pret = malloc(sz);	// 只能用 malloc 以避免死循环
        
        return pret;
    }
    
    // 默认为静态函数，所以没有 this 指针
    void operator delete(void *pointer)	// operator delete 函数的重载
    {
        free(pointer);
    }
    
private:
    int _id;
    char *_name;
    
}


int main()
{
    Student *pstu = new Student(123, "LiMing");
    // 函数体
    
    delete pstu;
    
    return 0;
}


实现只能生成栈对象

tips：栈区(stack) - 自动分配释放，存放函数的参数值，局部变量的值等

堆对象： // new 表达式的工作步骤

1. operator new 函数 ——> 私有
2. 构造函数
3. 指针

所以将 operator new/delete 设置为私有


实现代码

private:
    void *operator new(size_t sz)	// operator new 函数的重载
    {
        // 1. 调用名为 operator new 的标准库函数
        // 分配足够大的原始的未类型化的内存，以保存指定类型的一个对象
        void *pret = malloc(sz);
        
        return pret;
    }

	// 可省去对 operator delete 的私有操作
    void operator delete(void *pret)	// operator delete 函数的重载
    {
        free(pret);
    }


实现只能生成堆对象

tips：堆区(heap) - 由程序员分配释放，若不释放，程序结束时由 OS 回收

栈对象必须确保构造函数和析构函数同时为 public

将 析构函数 设为 private ——> delete 失效 ——> 在 class 的 public 中创建 destory 函数，调用 private 的析构函数


实现代码

public:
	// 由于要调用 this，所以不能将该函数设置为 static
	void destory()
    {
        /* this->~Student();	// 用 this 指向本身，从而调用 ~Student() 函数
        						// 但是删除仍不干净，operator delete 函数未被调用 */
        delete this;
    }

private:
    ~Student()	// 析构函数
    {
        delete[] _name;
        _name = nullptr;
    }




四、类域

作用域分为类作用域、类名的作用域以及对象的作用域


类的定义没有生存周期的概念，但类定义有作用域和可见域。

使用类名创建对象时，前提是类名可见，而类名是否可见，取决于类定义的可见域。


tip：一个重点为：当内部作用域声明了同外部作用域函数名相同的函数时（函数名相同即可！返回类型 和 形参列表 无所谓！），会隐藏外部作用域的所有同名函数。除非将外部作用域的同名函数定义为 virtual 虚函数。这一点在 继承和多态 中集中体现

灰黑桑
关注
专栏目录
C++面向对象学习（1）--- 封装
fang 0 jun的博客
02-04 429
权限相关 || 三种权限 在C++中 struct和class唯一的区别就在于 默认的访问权限不同 class默认是私有权限， struct默认是公共权限 三种权限 公共权限 public 类内可以访问 类外可以访问 私有权限 private 类内可以访问 类外不可以访问 （同时不可继承） 保护权限 protected 类内可以访问 类外不可以访问 ...
c++面向对象之封装
qq_32328985的博客
03-09 459
本系列是本人在学习c++的面向对象的知识点的笔记整理。 文章目录封装封装的意义 封装 c++面向对象的三大特征：封装、继承、多态。 封装的意义 类包括属性和方法。在设计类时，属性和方法写在一起, 属性和方法统称为成员，属性称为成员属性或者成员变量，行为称为成员函数或者成员方法。 类在设计时，可以把属性和方法放在不同的权限下，可以对它们加以控制。 访问权限：公共权限：public 成员类内...
C++类成员的访问权限以及类的封装
www.lyhdoctor.com
08-25 308
前面我们在定义类时多次使用到了 public 关键字，表示类的成员具有“公开”的访问权限，这节我们就来详细讲解。 C++通过 public、protected、private 三个关键字来控制成员变量和成员函数的访问权限，它们分别表示公有的、受保护的、私有的，被称为成员访问限定符。所谓访问权限，就是你能不能使用该类中的成员。 Java、C# 程序员注意，C++ 中的 public、private、protected 只能修饰类的成员，不能修饰类，C++中的类没有共有私有之分。 在类的内部（定义类的代码内部）
C++面向对象之封装
cheolcheol的博客
06-16 209
C++面向对象三大特性：封装、继承、多态。 万事万物皆为对象，对象上有其属性和行为。 具有相同性质的对象可以抽象为类。 1.封装
cpp代码-对象实例化 ----普通对象 和 指针对象
07-16
在这里，`john`就是一个`Person`类的普通对象，具有`name`和`age`两个成员变量，它们被初始化为"John"和30。 接下来，我们来看指针对象的实例化。在C++中，对象也可以通过指针来创建和管理。使用指针创建对象可以...
cpp代码-c++学习笔记——类与对象
07-14
在C++编程语言中，类和对象是...通过`main.cpp`和`README.txt`的学习，你不仅可以理解C++中类和对象的基本概念，还可以了解到如何在实际项目中应用这些概念。不断实践和探索，你将能更深入地掌握C++的面向对象编程。
cpp代码-C和C++：一些符号 || && ! :: . -> %
07-16
了解这些基础符号是学习C++的关键步骤，它们是构建更复杂结构和算法的基础。例如，逻辑运算符在条件控制（如if语句）中不可或缺；作用域解析运算符用于在复杂的代码结构中正确地引用和调用元素；成员访问运算符让...
C++面向对象--封装
m0_37940804的博客
04-15 339
目录 1. 封装 1.1.封装的意义a.将属性和行为做一个整体，表现生活中的事物 1.2.封装的意义b.将属性和行为加以权限控制 1.3.struct 和 class 区别 1.4.成员属性设置为私有 c++面向对象的三大特征为：封装，继承，多态。是c++很重要的一部分，也是比较难的一部分，希望通过我的讲解，你们可以对这三大特征更加理解和明白。 c++认为万事万物皆为对象，对象有其属性和行为。例如人也可以是一个对象，属性有姓名、年龄、身高、体重等，行为有走、跑、跳、吃饭、唱歌等。...
【C++】面向对象---封装
Zh0uKal1的博客
02-26 554
【C++】面向对象---封装
C++学习之路—面向对象—封装
weixin_45452278的博客
01-15 441
C++面向对象之封装定义封装的目的正好唠叨两句C++与C的区别public、private、protected的区别如何实现自己对private成员用途的一些理解 定义 在C++工程中，往往会有很多类的存在，为了避免类之间的相互影响。应该让类仅仅public一些必须让外界访问的成员，而隐藏private一些不想要公开的成员内容。这种信息的隐藏，就叫做C++类的封装。 封装的目的 封装的目的是为了保护私有成员变量 正好唠叨两句C++与C的区别 C++对C的最根本的改变就是把函数放进了结构之中，也就是我们
c++面向对象三大特性——封装
aaqq800520的博客
09-12 298
将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。封装本质上是一种管理，让用户更方便使用类。比如，身为计算机使用者，我们不需要关系内部核心部件，主板上的线路如何布局，CPU如何设计，如何关联各种硬件等，我们只需要知道怎么通过鼠标和键盘和计算机交互即可。计算机在设计制造的时候，在外面套上外壳，隐藏内部的各种细节，仅仅对外提供开机，鼠标以及各种插孔等，对计算机进行封装，保护内部元件，方便用户使用。
C++面向对象封装特性的实例分析与应用扩展（一）
m0_72677702的博客
08-02 197
接口是一个共享框架，供两个系统交互时使用，对于类，我们说公共接口。公共时使用类的程序，交互系统由类对象组成，而接口由编写类的人提供的方法组成。
C++之面向对象：封装、继承、多态。
weixin_45155703的博客
03-26 694
1、封装的意义：将属性和行为作为一个整体，表现生活中的事物；将属性和行为加以权限控制。 对象的初始化和清理 1、构造函数和析构函数 一个对象或者变量没有经过初始化就使用后果是未知的； 同样的使用完一个对象或者变量，没有及时清理，也会造成一定的安全问题。 C++用构造函数和析构函数去解决这类问题。 构造函数是对象的初始化，析构函数是对象的清理。 如果我们不提供这两个函数，编译器会自动补充。 构造函数语法：类名(){} 构造函数没有返回值，不需要写void; 函数名和类名相同； 构造函数可以有参数，因此可以发生
c++面向对象编程中封装的重要性
NL的博客
06-09 2606
C++中有个不成文的规定（其实在c++effective中已经成文），就是要将成员变量声明为private，这样做的好处有三点： 1.提高语法的一致性，客户在访问class成员的时候不需要思考是否要带括号，统一带括号访问，节省思考时间。 2.提升class对成员变量的访问控制精度，如果你的成员变量声明为public，这样所有的用户都能访问到它，但如果你声明为private，你就可以通过实现成员...
C++面向对象-1-类和对象以及封装
Anthony_tester的博客
01-11 874
新的公司，做之前没有做过的工作，全新的开始。由于项目是C++代码写的桌面版设计软件，所以作为测试开发，需要去做C++的白盒和SDK的API自动化测试。虽然，学习过Java这门面向对象编程语言，当前看C++的源码还是很吃力，所以打算，学习一下C++的面向对象部分。写博客，仅仅是督促我自己学习的一个方法，平时不做总结，只好通过写博客来记录学习过程，学习多了，自然就会产生总结和提炼，这需要...
C++ —— 封装(1)
Zero's Zone
10-22 173
（部分内容来自慕课网） 类和对象 根据不同的目的抽象不同的信息 封装：选择性暴露 访问限定符：public、protected、private 对象实例化 从栈中实例化（自动回收） 从堆中实例化（需要手动将申请的内存释放） 对象的访问 栈中使用 栈中使用 new申请一个对象，使用完之后需要delete，并指向NULL Demo 定义了一个类，通过栈和堆两种不同的方式对类的对象进行实例化...
想学习cpp中的类和对象要怎么学
最新发布
10-22
学习C++中的类和对象通常涉及以下几个步骤： 1. **理解基本概念**： - C++中的类是一种用户自定义的数据结构，它封装数据（成员变量）和操作数据的方法（成员函数）。 - 对象是类的一个实例，用于表示现实世界中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值