C++ 第二章 封装

最新推荐文章于 2024-07-25 23:22:43 发布
最新推荐文章于 2024-07-25 23:22:43 发布
阅读量118 收藏
点赞数
分类专栏： c++ 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44139121/article/details/125917730
版权

封装

我该有的我该做的

构造函数与析构函数

构造/析构函数使用方式
默认构造函数People a;
People(const People &a)拷贝构造，与=不等价
People(string name);People a(“bug”)
~People()无

在这里插入图片描述

class People {
public:
    People(){}
    People(string name) {//有参构造
        this->name = name;
    }
    /*People() { 默认构造函数
        arr = new int[10];
        cout << "default constructor" << endl;
    }*/
    ~People() {
        cout << "destructor" << endl;
    }
    string name;
    //int *arr;
};

int main() {
    People b("fangsong");
    People a = string("string");
    //a.arr[9] = 12
    cout << a.name << endl;
    return 0;
}

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <stack>
#include <algorithm>
#include <string>
#include <map>
#include <set>
#include <vector>
using namespace std;

class People {
public :
    People() {}
    //People() = default; //  //隐藏规则变为显示规则，易于代码维护
   //People() = delete;
    People(string name) {
        cout << "param constructor" << endl;
        this->name = name;
    }
    People(int x) {
        cout << "int param constructor" << endl;
        this->x = x;
    }
    People(const People &a) {
        cout << "copy constructor" << endl;
        this->name = a.name;
        this->x = a.x;
    }
    
    void operator=(const People &a) {
        cout << "operator =" << endl;
        this->name = a.name;
        this->x = a.x;
        return ;
    }

    ~People() {
        cout << "destructor" << endl;
    }
    string name;
    int x;
};

void incr(int &a) {
    a += 1;
    return ;
}

int add(People a, People b) {
    return a.x + b.x;
}

int main() {
    int n = 7;
    incr(n);
    cout << n << endl;
    cout << add(4, 5) << endl;
    People a("hug");
    People b = string("hug");
    People c(543);
    People d = 678;
    cout << a.name << endl;
    cout << b.name << endl;
    cout << c.x << endl;
    cout << d.x << endl;
    c = 987;
    cout << c.x << endl;
    d = string("duanchenyang");
    cout << d.name << endl;
    People e = a;
    cout << e.name << endl;
    cout << e.x << endl;
    c = a;
    cout << c.name << endl;
    cout << c.x << endl;
    return 0;
}

类属性方法

static 类成员，类方法

类的成员与方法

class People {
public:
	void say(string word);
	void run(location &loc)
	///
	static void is_valid_height(double height);
	/
private:
	static int totle;
	string __name;
	Day __birthday;
	double __height;
	double __wright;
};

类属性与类方法中，类属性可以记录类对象的个数，类方法中不能访问this指针;

const方法

不去修改对象中的值

const类型对象只能调用const类型方法

修饰后只能类const访问

class People {
public:
	void say(string word);
	void run(location &loc)
	///
	string &name() const()
	///
	static void is_valid_height(double height);
private:
	static int totle;
	string __name;
	Day __birthday;
	double __height;
	double __wright;
};

类属性与const代码演示

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <stack>
#include <algorithm>
#include <string>
#include <map>
#include <set>
#include <vector>
using namespace std;

class Point {
public :
    Point() {
        cout << "constructor : " << this << endl;
        Point::total_cnt += 1;
    }
    Point(const Point &a) : Point() {
        cout << "copy constructor : " << this << endl;
        this->x = a.x;
        this->y = a.y;
    }
    Point(double z) : Point() {
        cout << "convert constructor : " << this << endl;
        this->x = 99, this->y = 99;
    }
    Point(int x, int y) : Point() {
        cout << "param constructor : " << this << endl;
        this->x = x;
        this->y = y;
    }

    void operator=(const Point &a) {
        cout << "operator= : " << this << endl;
        this->x = a.x, this->y = a.y;
        return ;
    }
    void set(int x, int y) {
        this->x = x;
        this->y = y;
    }
    void seek() const {
        seek_cnt += 1;
        cout << x << " " << y << endl;
    }

    void s() const{
        cout << seek_cnt << endl;
    }

    static int T() { return Point::total_cnt; }//类承成员方法

    ~Point() {
        cout << "destructor : " << this << endl;
        Point::total_cnt -= 1;
    }

private:
    int x, y;
    mutable int seek_cnt = 0;
    static int total_cnt;//类方法成员属性
};
int Point::total_cnt = 0;

void test() {
    Point a;
    cout << Point::T() << endl;
    return ;
}
int main() {
    Point a;
    cout << a.T() << endl;
    test();
    Point b;
    cout << b.T() << endl;
    Point c(3, 4);
    cout << c.T() << endl;
    Point d(3.4);
    cout << d.T() << endl;
    c = 5.6;
    cout << c.T() << endl;
    cout << &a << endl;
    cout << &b << endl;
    cout << &c << endl;
    cout << &d << endl;
    d.seek();
    c.seek();
    const Point e(6, 7);
    e.seek();
    e.seek();
    e.seek();
    e.seek();
    e.s();
    return 0;
}

深拷贝与浅拷贝

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <vector>
#include <map>
#include <cmath>
#include <queue>
using namespace std;

class A {
public :
    A() {
        this->arr = new int[100];
    }
    A(const A &obj) : x(obj.x), y(obj.y) {
        this->arr = new int[100];
        memcpy(this->arr, obj.arr, sizeof(int) * 100);
    }
    int *arr;
    int x, y;
};

int main() {
    A a;
    a.x = 3, a.y = 6;
    a.arr[0] = 123;
    A b = a;
    b.arr[0] = 456;
    cout << a.arr[0] << " " << b.arr[0] << endl;
    cout << b.x << " " << b.y << endl;
    b.x = 6;
    cout << a.x << " " << a.y << endl;
    cout << b.x << " " << b.y << endl;
    return 0;
}

类型转换

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<iomanip>
#include<algorithm>
#include<map>
#include<vector>
#include<set>
using namespace std;
class BigInt{
    public :
    BigInt() {}
    BigInt(int x) {
        num.push_back(x);
        process_digit();
    }
    friend ostream &operator<<(ostream &, const BigInt &);
    private:
    vector<int>num;
    void process_digit() {
        for(int i = 0; i < num.size(); i++) {
            if(num[i] < 10) continue;
            if(i + 1 == num.size())num.push_back(0);
            num[i + 1] = num[i]/10;
            num[i] %= 10;
        }
        return;
    }
};

ostream &operator<<(ostream &out, const BigInt &a) {
    for(int i = a.num.size() - 1; i >= 0; i--) {
        out << a.num[i];
    }
    return out;
}

void func(BigInt a) {
    cout << "func : " << a << endl;
}

int main() {
    BigInt a;
    a = 1234;
    cout << a << endl;
    func(5670);
    return 0;
}

运算符重载

在这里插入图片描述
在这里插入图片描述

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<iomanip>
#include<algorithm>
#include<map>
#include<vector>
#include<set>
using namespace std;

namespace haizei {
    
class istream{
public :
    istream &operator>>(int &n){
        std::cin >> n;
        return *this;
    }
private:

};

class ostream {
public :
    ostream &operator<<(int &n) {
        std::cout << n;
        return *this;
    }
    ostream &operator<<(const char *msg) {
        std::cout<< msg;
        return *this;
    }
private:

};
istream cin;
ostream cout;
};

haizei::ostream &operator<<(haizei::ostream &out, double &z) {
    std::cout << z;
    return out;
}

ostream &operator+(ostream &out,const int &z){
    out << z;
    return out;
}

int main() {
    int n, m;
    haizei::cin >> n >> m;
    haizei::cout << n <<" "<< m << "\n";
    double k = 5.6;
    haizei::cout << k << "\n";
    cout + 8 + 9 + 10;
    cout + k;
    (((((cout + 8 )<< " ") + 9) << " ") + 10) << endl;
    return 0;
}



#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<iomanip>
#include<algorithm>
#include<map>
#include<vector>
#include<set>
using namespace std;

class Point{
public:
    Point() : __x(0), __y(0){}
    Point(int x, int y) : __x(x), __y(y){}
    int x() const {return __x;}
    int y() const {return __y;}
    Point operator+(const Point &a) {
    /*this<---a
     * a<----b 
     */
    return Point(x() + a.x(), y() + a.y());
    }
    Point &operator+=(const Point &a) {
        __x += a.x();
        __y += a.y();
        return *this;
    }
    Point &operator++(){
        __x +=1;
        __y +=1;
        return *this;
    }
    Point operator++(int) {
        Point temp(*this);
        __x += 1;
        __y += 1;
        return temp;
    }
private:
    int __x, __y;
};

ostream &operator<<(ostream &out, const Point &a) {
    cout << "Point (" << a.x() << "," <<a.y() << ")";
    return out;
};



int main() {
    Point a(4, 5), b(3, 4), c(1, 1);
    cout << a << endl;
    cout << b << endl;
    cout << c << endl;
    cout << a << " " << b << endl;
    cout << a + b << endl;
    cout << ++(c += b) << endl;
    cout << c << endl;
    cout << c++ << endl;
    cout << c << endl;
    int n = 6, m = 7;
    (n += m) ++;
    cout << n << endl;
    return 0;
}




#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<iomanip>
#include<algorithm>
#include<map>
#include<vector>
#include<set>
using namespace std;

class A{
public:
    A() {
        arr = new int[10];
    }
    A(const A &a) : A() {
        for(int i = 0; i < 10; i++) {
            this->arr[i] = a.arr[i];
        }
        this->x = a.x;
        this->y = a.y;
        return;
    }
    int x, y;
    int *arr;
};

class B{
public :
    B() : obj(nullptr) {
        arr = new int[10];
        arr[3] = 9973;
    }
    B(A *obj) : B() {
        this->obj = obj;
    }
    int operator() (int a, int b) {
        return a + b;
    }
    int &operator[](int ind) {
        return arr[ind];
    }
    void operator[](const char *msg) {
        cout << msg << endl;
        return;
    }
    A *operator->() {
        return obj;
    }
    A &operator*() {
        return *obj;
    }
    ~B() {
        delete arr;
    }
private:
    int *arr;
    A *obj;
};

ostream &operator <<(ostream &out, const A &a) {
    out << "A（" << a.x << " ," << a.y << ")" << endl;
    return out;
}

int main() {
    B add;
    cout << add(3, 4) << endl;
    cout << add[3] << endl;
    add[3] = 8876;
    cout << add[3] << endl;
    add["hello world"];

    A a, b(a);
    a.x = 67, a.y = 99;
    B p = &a;
    cout << p->x << " " << p->y << endl;
    cout << *p << endl;
    
    a.arr[3] = 9973;
    b.arr[3] = 6687;
    cout << a.arr[3] << endl;
    cout << b.arr[3] << endl;
    return 0;
}
橙虚的猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第一章 C++入门
qq_43205256的博客
04-26 1507
1. C++关键字(学习要求：了解) C++总计63个关键字，包括C语言中的32个关键字 2. 命名空间(学习要求：掌握) 2.1 命名空间定义 关键字 空间的名字 {空间的成员} namespace spacename {spacemember1、spacemember2 ......} 例如： //1. 普通的命名空间 namespace N1 // nam......
C++课后习题第一章
lornaleo的博客
01-11 732
第一章课后作业 一、单选题（共6题，75分） 1. (单选题)C++是（ ）。 A.面向对象的程序设计语言 B.结构化程序设计语言 C.既是面向对象的程序设计语言又是结构化的程序设计语言 D.非结构化的程序设计语言 我的答案: C正确答案: C 2. (单选题)C++语言属于（ ）。 A.机器语言 B.低级语言 C.中级语言 D.高级语言 我的答案: D正确答案: D 3. (单选题)下面关于对象概念的描述中，错误的是（ ）。 A.对象就是C语言中的结构变量 B.对...
高性能服务器系列-第二章 Mysql C++ 封装
huiyue2007的博客
12-21 963
高性能服务器系列-第二章 Mysql C++封装，简化Mysql的使用
第十一章 C++ 封装/继承/多态
konkon2012的博客
09-20 987
面向对象程序设计（OOP）是一种计算机编程架构，主要目标是为了实现代码的重用性、灵活性和扩展性。面向对象程序设计以对象为核心，程序由一系列对象组成。对象间通过消息传递（一个对象调用了另一个对象的函数）相互通信，来模拟现实世界中不同事物间的关系。 面向对象程序设计有三大特性：封装，继承，多态。还有一种特性就是抽象。 封装的基本体现就是对象，封装使得程序的实现“高内聚、低耦合”的目标。封装就是把数据和数据处理包围起来，对数据的处理只能通过已定义的函数来实现。封装可以隐藏实现细节，使得代码模块化。继承
C++第一章：C++语言概述
qq_66136291的博客
04-14 1521
一、计算机系统组成 二、计算机基本结构 三、指令、程序和软件 （一）指令 指令是计算机执行某种操作的机械命令，它可以被计算机硬件直接识别和执行。计算机指令用二进制代码表示，一条指令通常由两个部分组成： （二）程序 计算机程序是指完成一定功能的指令的有序集合。 （三）软件 软件是指程序、程序运行所需要的数据以及开发、使用、维护这些程序所需要的文档的集合...
C++学习之旅 第二章 printf与cout
wo_ai_luo_的博客
11-12 9776
printf函数是格式化输出函 ，数，一般用于向标准输出设备按规定格式输出信息。在C++中产生格式化输出的函数。其向终端输出字符。printf中的f的意思是format，它的作用是按照指定的格式输出数据。printf也是C++中很重要的一个函数，它能让用户可以与程序交流，是一个多才多艺的函数。printf 将变量的内容输出到显示器上。
C++学习笔记【封装、继承、多态】
weixin_45045804的博客
09-29 1818
c++
高性能服务器系列-第三章 Protobuf封装(C++/C#/Go)
huiyue2007的博客
12-21 927
高性能服务器系列-第三章 Protobuf封装(C++/C#/GO），为服务端和客户端数据通信提供便捷方案。
第十二章 C++ 数据存储与释放
konkon2012的博客
09-20 1933
程序开发过程中，所有的数据都需要放置到内存中，尤其是游戏开发中涉及的3维模型以及画面的渲染，这是消耗性能的关键部分。如果处理不当，很有可能造成内存溢出的情况发生，导致整个程序崩溃。防止内存溢出情况发生的关键点在于合理的分配和释放内存。Java和C#语言都是运行在虚拟机（运行时）上的，虚拟机都有一种垃圾回收机制来释放数据持有的内存，这不需要开发人员人工干预的。C++语言没有这种机制，因此需要开发人员手动完成某些数据占用的内存。这个时候，我就必须了解数据变量的生命周期的概念。 C++程序运行过程中，系统需
C++面向对象程序设计第二版（谭浩强） 第二章
xxxflower的博客
04-10 1201
2.1.1 对象 客观世界中任何一个事物都可以看做一个对象。 对象是构成系统的基本单位。 对象的两个要素： （1）静态特征 属性 （2）动态特征 行为 对象应能根据外界给的消息进行相应操作。 对象的组成： （1）数据 （2）函数 封装与信息隐蔽 可以对一个对象进行封装处理。（把它的一部分属性和功能对外屏蔽） 抽象 抽象的过程是将有关事物的共性归纳，集中地过程。 抽象的作用是表示同一类事物的本质。 类是对象的抽象,而对象则是类的特例，或者说是类的具体表现形式。 继承与重用
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1262
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++ | Leetcode C++题解之第283题移动零
Ddddddd_158的博客
07-25 459
C++ | Leetcode C++题解之第283题移动零
【C++】C++中的find方法介绍
qq_35902025的博客
07-25 312
find 函数是 std::string 类中非常有用的成员函数之一，它提供了灵活的方式来查找子字符串或字符。使用 npos 可以检查查找操作是否成功。
《Cross-Modal Dynamic Transfer Learning for Multimodal Emotion Recognition》
buyaotutou的博客
07-25 1102
例如：第一章 Python 机器学习入门之pandas的使用文章链接Multimodal Emotion Recognition is an important research area for developing human-centric applications, especially in the context of video platforms. Most existing models have attempted to develop sophisticated fusion tech
C++ primer plus 第16章string 类和标准模板库, 关联容器
zhyjhacker的博客
07-25 721
C++ primer plus 第16章string 类和标准模板库, 关联容器。
【C++】选择结构-多条件if语句
weixin_58995084的博客
07-24 232
else if{若第一个条件未满足，执行此条件} {第二个条件满足执行此操作}else if{若第二个条件未满足，执行此条件} {第三个条件满足执行此操作}else{若所有条件都不满足执行此操作}多条件if语句格式为。
Windows图形界面(GUI)-MFC-C/C++ - Dialog
最新发布
0xCC说逆向
07-25 1078
流程打开资源视图：在Visual Studio中，右键点击资源文件夹（通常是），选择“添加” -> “资源”。添加对话框资源：在弹出的对话框中选择“Dialog”，然后点击“新建”。设计对话框：在资源编辑器中，你可以拖放控件到对话框上，如按钮、文本框、列表框等。拓展资源ID：每个对话框都有一个唯一的资源ID，用于在代码中引用。对话框编辑器：用于可视化地设计和布局对话框。
C：图案打印
2401_85010100的博客
07-23 909
空心正方形，空心三角形，X形，沙漏图案打印
C++ //练习 15.28 定义一个存放Quote对象的vector，将Bulk_quote对象传入其中。计算vector中所有元素总的net_price。
Made in Code
07-25 578
C++ Primer（第5版） 练习 15.28
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值