C++笔记：类和对象(一)

news2024/11/21 2:23:46

类和对象

        认识类和对象

         先来回忆一下C语言中的类型和变量，类型就像是定义了数据的规则，而变量则是根据这些规则来实际存储数据的容器。类是我们自己定义的一种数据类型，而对象则是这种数据类型的一个具体实例。类就可以理解为类型，而对象就可以理解为变量，而且对象是更加高级的变量。

        类型 = 类型数据 + 类型操作

        比如double类型

        他的数据类型占用8字节，并且可以表示成小数。

        类型操作可以加减乘除，但是它不支持模(%)运算。

        那么类就是包含了类型数据和类型操作的一个集合。

        也可以理解为数据就是类的属性，操作就是类的行为

        通过下面我定义的一个人的类，那么height,sex, age都是这个类的类型数据，而类型操作就是函数run和函数speak。

class People {
    double height;//身高
    char sex;//性别
    int age;//年龄
    string name;//姓名
    void run() {//跑
        cout << "I can run" << endl;
    }
    void speak() {//说话
        cout << "I can speak" << endl;
    }
};

        那么我需要一个特定的人的时候，我就需要定义一个对象用来存这个特定人的属性。

        下面的用类定义一个对象，并且对他的属性进行赋值。

People a;
a.name = "Zhang san";
a.age = 18;
a.sex = '1';//女0，男1
a.height = 1.89;

        而我需要这个人进行说话或者跑时，就需要调用他相应的操作，也就是函数。

a.run();
a.speak();

        访问权限

        public：是公共的资源，是谁都可以访问的资源，比如空气，阳光，公共场合都是谁都可以访问进行使用的。

        private：是私有的资源，是只能类自己进行访问的资源，比如每个人自己的私人物品，是只能自己使用和访问的。

        protected：是受保护的资源，是只能自己访问以及自己的子类访问的资源，比如你儿子可以使用你的东西。(在后续文章继承时会用到protected权限)

        friendly：是在关键字friend声明后，它允许被声明后的类或函数访问这一个类的私有或受保护的资源，比如你的好兄弟在你的允许下可以访问和使用你的私人物品。(在后续的文章中会更新到使用)

        重点：这里的访问权限是规定的类外对该类类内的访问权限。

        比如我在一个类中定义了一个访问权限为私有的方法，那么我只能在这个类的内部进行调用，在类外是无法调用的，除非我对这个方向进行了friend友元声明。

        对于为什么要为什么要有访问权限的设置，看如下代码：

#include<iostream>
using namespace std;


class People {
public :
int age;
    void speak() {
        cout << "my age is "<< age << endl;
        return ;
    }
};


int main() {
    People a;
    a.age = -100;
    a.speak();
    return 0;
}

        如果对于age是public公有访问的，那么在设置年龄的将不会受到限制，对于这份代码可能没有问题，如果在以后设计项目或者工程时，就会造成灾难性的错误。

        那么正确的写法应该如下，把age设置为私有的，对age赋值时，定义一个函数来进行对age赋值，并判断值是否在正确范围内，对于获取age值也定义一个函数进行来获取。

#include<iostream>
using namespace std;


class People {
public :
    void speak() {
        cout << "my age is "<< age << endl;
        return ;
    }
    void set_age(int x) {
        if (age <= 0 || age > 1000) {
            perror("your age is error\n");
            exit(1);
        }
        age = x;
        return ;
    }
    int get_age() {
        return age;
    }
private :
    int age;
};


int main() {
    People a;
    a.set_age(-100);
    a.speak();
    return 0;
}

构造函数和析构函数

        定义一个对象的流程：

     对于构造函数的详细解析如下代码：

#include<iostream>
using namespace std;

class A {
public :
    A() {//默认构造函数
        cout << "default constructor" << endl;
    }
    //如果这里没有const关键字,传入的对象是const声明的那么就会报错
    //如果没有&(引用),那么将会造成无限套娃的拷贝构造
    //假如这里没有&，那么这里的形参就相当于实参给他赋值
    //而赋值就是 A a = b, b是实参传入的值
    //那这里就会又调用构造函数,形成无限套娃
    A(const A &a) {
        this->x = a.x;
        this->y = a.y;
        cout << "copy constructor" << endl;
    }
    A(int x, int y) {//有参构造函数
        cout << "have parameter constructor" << endl;
        this->x = x;//this表示当前对象的地址
        this->y = y;
    }
    void operator=(const A &a) {//这个函数是=运算符重载，是类中默认有的
        cout << "this is assigment"  << endl;
        return ;
    }
    A(int x) {//转换构造函数
        cout << "conversion constructor" << endl;
        this->x = x;
        this->y = 0;
    }
    void output() {
        cout << "(" << x << ", " << y << ")" << endl;
    }
    ~A() {//析构函数
        cout << "destructor" << endl;
    }
private :
    int x, y;
};


void func(A a) {
    cout << "func : ";
    a.output();
    return ;
}


int main() {
    A a;//调用默认构造函数
    cout << "1-------------------------" << endl;
    A b(1, 2);//调用有参构造
    cout << "2-------------------------" << endl;
    //这里就调用了拷贝构造函数
    A e = b;
    cout << "3-------------------------" << endl;
    //这里只是运用了普通赋值运算符
    //通过执行会发现没有执行任何构造函数
    a = b;
    cout << "4-------------------------" << endl;
    //调用转换构造，将int类型转换为A类型
    //这里也可以是另一个类型的对象，那也是转换构造
    //不过还需要从新定义一个需要转换构造的函数,里面的参数就是对应的类型
    A c(3);
    cout << "5-------------------------" << endl;
    //这里调用的是拷贝构造函数，将对象b进行拷贝给函数形参a
    func(b);
    func(c);
    cout << "6-------------------------" << endl;
    //对于这中函数调用情况
    //这里就会用到转换构造
    //他会隐式的将int类型5通过转换构造转会为A类型
    func(5);
    cout << "7-------------------------" << endl;
    //这里相当于A d(4);
    //这里可以这样理解
    //等号类型相同编程才能通过
    //那么4，int类型就会通过转换构造变成A类型
    //如果没有转换构造那么就编译无法通过
    A d = 4;
    a = 6;
    cout << "8-------------------------" << endl;
    return 0;
}

构造函数的初始化列表

构造函数中的初始列表使用：

#include<iostream>
using namespace std;

class C {
public:
    C(int n) {
        this->num = n;
        cout << "C coversion constructor" << endl;
    }
    void output() {
        cout << num;
    }
private :
    int num;
};

class A {
public :
    //:后面是构造函数的初始化列表
    A(int a) : a(a), b(10), c(6) {
        cout << "A constructor" << endl;
    }
    void output() {
        cout << " " <<a << " " << b << " ";
        c.output();
        cout << endl;
        return ;
    }
private :
    int a, b;
    C c;
};


int main() {
    A a(2);
    a.output();
    return 0;
}

构造函数和析构函数的调用顺序

如下这份代码：

#include <iostream>
#include <string>
using namespace std;


class A {
public :
    A() {};
    A(string n)  {
        name = n;
        cout << name << " class A construtor" << endl;
    }
    ~A() {
        cout << name << " class A destructor" << endl;
    }
int *p;
private :
    string name;
};

class B {
public :
    //:a(a)
    //:后面是构造函数时，最该对象中的成员属性进行初始化操作
    B(string n, A &a) : a(a){
        name = n;
        cout << name << " class B construtor" << endl;
        //new关键字可以理解为，C语言中malloc去堆区中开辟一段空间
        a.p = new int[10];
        return ;
    }
    A &a;//创建一个引用属性，这里&a可以暂时理解为取a的地址
    ~B() {
        //delete就相当于C语言中的free对开辟空间的释放
        delete a.p;
        cout << name << " class B destructor" << endl;
    }
private :
    string name;
};


int main() {
    A a("a");
    B b("b", a);
    return 0;
}

执行结果：

        可以发现，析构顺序是构造顺序反过来的，通过代码可以发现在B中的有参构造中用到了a对象的引用，然后对a对象的p指针开辟了一段空间，如果析构时顺序和构造顺序一样的那么，在析构b对象时，去delete a.p去释放开辟的空间时，a对象已经被析构掉了，那就也无法去找a对象中的指针p了。

类属性与方法 

        对于上面的代码的类中，它们只有成员属性和成员方法。

        就拿文章中的第一份代码来看，对于属性，也就是类中的变量，他所存储的值是跟着对象改变而改变的，而类中的两个方法(函数)，也是随着对象改变而改变的，因为它们的输出也是不同的。所以这些叫做成员属性和成员方法。

class People {
    double height;//身高
    char sex;//性别
    int age;//年龄
    string name;//姓名
    void run() {//跑
        cout << name << " can run" << endl;
    }
    void speak() {//说话
        cout << name << " can speak" << endl;
    }
};

 下面这份代码是对成员属性和成员方法的使用：

#include<iostream>
using namespace std;


class Point {
    public :

    Point() : x(0), y(0) {} //默认构造
    //区分x和y
    //在x(x),括号外是成员属性x,括号内是形参x
    Point(int x, int y) : x(x), y(y) {} //有参构造
    void set_x (int x) { this->x = x; }
    void set_y (int y) { this->y = y; }
    int get_x() { 
        //访问类中的类属性
        Point::get_x_cnt += 1;
        return this->x; 
    }
    int get_y() { return this->y; }
    //这里是直接定义了类方法
    static int x_cnt() {
        return Point::get_x_cnt;
    }
    private :
    //这里只是声明了这个变量
    //get_x_cnt,记录变量x在被get时,在整个程序执行时被调用了多少次
    static int get_x_cnt;
    int x, y;
};

//这里就是定义了get_x_cnt, 并且给他的值进行了初始化
int Point::get_x_cnt = 0;



int main() {
    Point p1(3, 4), p2(5, 6);
    cout << p1.get_x() << ", " << p1.get_y() << endl;
    cout << p2.get_x() << ", " << p2.get_y() << endl;
    p1.get_x();
    p1.get_x();
    p1.get_x();
    cout << "x_cnt : " << Point::x_cnt() << endl;
    return 0;
}

 const 方法

对于const和mutable关键字使用，对于上一份代码的修改：

#include<iostream>
using namespace std;


class Point {
    public :
    Point() : x(0), y(0) , get_x_cnt(0){} //默认构造
    Point(int x, int y) : x(x), y(y), get_x_cnt(0) {} //有参构造
    void set_x (int x) { this->x = x; }
    void set_y (int y) { this->y = y; }
    int get_x() const { //修改处
        get_x_cnt += 1;
        return this->x; 
    }
    int get_y() const { return this->y; }//修改处
    int x_cnt() const {//修改处
        return get_x_cnt;
    }
    private :
    //现在get_x_cnt，表示当前对象对get_x函数的调用次数
    //mutable关键字表示不收const关键之的限制
    //所以就算有const关键字，那么mutable声明的变量也可以进行修改
    mutable int get_x_cnt;
    int x, y;
};




int main() {
    const Point p(10, 15), p2(1, 2);
    cout << p.get_x() << ", " << p.get_y() << endl;
    p2.get_x();
    p2.get_x();
    cout << "p1 : get_x_cnt = " << p.x_cnt() << endl;
    cout << "p2 : get_x_cnt = " << p2.x_cnt() << endl;
    return 0;
}

类的声明和定义

还是对类属性和类方法的那份代码进行修改：

#include<iostream>
using namespace std;

//在类中只放方法的声明
class Point {
    public :
    Point();
    Point(int x, int y);
    void set_x (int x);
    void set_y (int y);
    int get_x() const;
    int get_y() const;
    static int x_cnt();
    private :
    static int get_x_cnt;
    int x, y;
};

//对于类中的方法进行实现
//那么就可以将这两部分拆开
//定义放在源文件中，声明放在头文件中
Point::Point() : x(0), y(0) {}
Point::Point(int x, int y) : x(x), y(y) {}
void Point::set_x(int x) {
    this->x = x; 
}

void Point::set_y(int y) {
    this->y = y; 
}

int Point::get_x() const{
    Point::get_x_cnt += 1;
    return x; 
}

int Point::get_y() const{
    return y;
}

int Point::x_cnt() {
    return Point::get_x_cnt; 
}

int Point::get_x_cnt = 0;

int main() {
    Point p1(3, 4), p2(5, 6);
    cout << p1.get_x() << ", " << p1.get_y() << endl;
    cout << p2.get_x() << ", " << p2.get_y() << endl;
    p1.get_x();
    p1.get_x();
    p1.get_x();
    cout << "x_cnt : " << Point::x_cnt() << endl;
    return 0;
}

default和delete关键字

    delete和default关键字引用代码：

#include<iostream>
using namespace std;

class A {
public :
    //A() = delete;
    A() {
        cout << "default constructor" << endl;
    }
    A(int n) : x(n) {
        cout << "conversion constructor" << endl;
    }
    A(const A &) {
        cout << "copy constructor" << endl;
    }
private :
    int x;
};

class B {
public :
    B() = default;
    B(const B&) = default;
private :
    A a1, a2, a3;
};

class C {
public :
    C() = default;
    //C(const C&) {}//这种情况叫撒比构造
    C(const C&) = default;
private :
    A a1, a2, a3;
};

class Point {
public :
    Point() = default;//请求编译器生成默认构造函数
    Point(int x, int y) : x(x), y(y) , p(new int(5)), a(1){}
    //Point(const Point &) = delete;//删除编译器的拷贝构造函数
    //Point(const Point &) = default;//拷贝函数生成默认行为,在使用这个拷贝构造函数时就会造成双重释放的报错
    //这就是深拷贝
    Point(const Point &a) : x(a.x + 1), y(a.y + 2), a(a.a){
        //如果这里成员属性a直接用这样去赋值拷贝
        //那么成员属性a就会使用A类的默认构造函数进行构造
        //而A类的默认构造函数已经被删除了，那么就会报错
        //this->a = a.a;
        this->p = new int;
        *(this->p) = *(a.p);
    }
    ~Point() {
        delete p;
    }
private :
    A a;
    int *p;
    int x, y;
};


int main() {
    Point p1(1, 2), p2 = p1;
    return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1609561.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

在Ubuntu 22.04上安装配置VNC实现可视化

在Ubuntu 22.04上安装配置VNC实现可视化

前面安装的部分可以看我这篇文章 在Ubuntu 18.04上安装配置VNC实现Spinach测试可视化_ubuntu18开vnc-CSDN博客 命令差不多一样&#xff1a; sudo apt update sudo apt install xfce4 xfce4-goodies sudo apt install tightvncserver这个时候就可以启动server了 启动server&…
阅读更多...
音频---数字mic

音频---数字mic

一、常见的数字mic pdm麦通过codec芯片将数字麦转换为i2s信号输入到SOC 纯pdm麦就是直接进入SOC的pdm接口&#xff0c;走的是PDM信号&#xff0c;PDM信号就是两个线&#xff0c;一根数据线一根时钟线&#xff08;如顺芯ES7201/7202把MIC信号转换成PDM&#xff09;。 二、DMIC…
阅读更多...
等保合规：保护企业网络安全的必要性与优势

等保合规：保护企业网络安全的必要性与优势

前言 无论是多部网络安全法律法规的出台&#xff0c;还是最近的“滴滴被安全审查”事件&#xff0c;我们听得最多的一个词&#xff0c;就是“等保。” 只要你接触安全类工作&#xff0c;听得最多的一个词&#xff0c;一定是“等保。” 那么&#xff0c;到底什么是“等保”呢…
阅读更多...
Docker部署SpringBoot服务(Jar包映射部署)

Docker部署SpringBoot服务(Jar包映射部署)

介绍 项目在docker部署运行以后&#xff0c;每次需更新jar包时&#xff0c;都得重新制作镜像&#xff0c;再重新制作容器。流程及其繁琐&#xff0c;效率极低。 以下步骤是在不更新镜像和容器的前提下&#xff0c;直接更新jar完成项目更新的操作。 不重新制作镜像部署 1. 创…
阅读更多...
Python简化远程部署和系统管理的工具库之fabric使用详解

Python简化远程部署和系统管理的工具库之fabric使用详解

概要 Python Fabric库是一个用于简化远程部署和系统管理的工具库。它提供了一组简洁而强大的函数和工具，可以帮助开发者轻松地在多台远程主机上执行命令、上传文件、下载文件等操作，从而实现自动化部署和管理。 安装 要使用Python Fabric库，首先需要安装Fabric模块。可以通…
阅读更多...
OpenHarmony实战开发-如何使用text组件的enableDataDetector属性实现文本特殊文字识别。

OpenHarmony实战开发-如何使用text组件的enableDataDetector属性实现文本特殊文字识别。

介绍 本示例介绍使用text组件的enableDataDetector属性实现文本特殊文字识别。 效果图预览 使用说明 1.进入页面&#xff0c;输入带有特殊文字的信息并发送&#xff0c;对话列表中文本会自动识别并标识特殊文字。目前支持识别的类型包括电话号码、链接、邮箱和地址&#xff…
阅读更多...
Zynq7000系列中PL时钟使用

Zynq7000系列中PL时钟使用

可编程逻辑&#xff08;PL&#xff09;具有自己的时钟管理生成和分配功能&#xff0c;并从处理器系统&#xff08;PS&#xff09;中的时钟发生器接收四个时钟信号&#xff08;如图25-10所示&#xff09;。 在嵌入式系统中&#xff0c;PL时钟的管理和分配对于确保逻辑电路的正确…
阅读更多...
协程的意义（二）

协程的意义（二）

1.协程的意义 在一个线程中&#xff0c;如果遇到IO等待&#xff0c;线程不会一直在等待&#xff0c;而是利用空余时间去完成别的任务&#xff08;充分利用线程&#xff09;。 示例&#xff1a;下载图片 ①普通的方式下载图片&#xff08;同步方式&#xff09; ②使用协程的方…
阅读更多...
发泡机液压站比例阀放大器

发泡机液压站比例阀放大器

发泡机液压站是提供动力和压力以驱动发泡机工作的系统。 发泡机是一种用于制备聚氨酯发泡材料的设备&#xff0c;而液压站则扮演着为发泡机提供必要动力的角色。具体来看&#xff0c;液压站的主要组成包括&#xff1a; 液压油箱&#xff1a;存储液压油&#xff0c;为系统提供液…
阅读更多...
【Applied Algebra】隐藏子群问题和Shor算法的新视角

【Applied Algebra】隐藏子群问题和Shor算法的新视角

隐藏子群问题和Shor算法的新视角 隐藏子群问题是指给定一个群和一个函数,该函数对于群的一个子群是常数,并且对于子群的任何两个不同的左陪集有不同的值,问题是找到这个子群.HSP是许多量子算法的基础,其中最著名的是Shor的算法,它可以用来分解大整数和计算离散对数,这直接威胁到…
阅读更多...
小目标检测——鸟类数据集

小目标检测——鸟类数据集

引言 亲爱的读者们&#xff0c;您是否在寻找某个特定的数据集&#xff0c;用于研究或项目实践&#xff1f;欢迎您在评论区留言&#xff0c;或者通过公众号私信告诉我&#xff0c;您想要的数据集的类型主题。小编会竭尽全力为您寻找&#xff0c;并在找到后第一时间与您分享。 …
阅读更多...
nvidia-smi CUDA Version:N/A

nvidia-smi CUDA Version:N/A

问题 nvidia-smi显示&#xff1a;CUDA Version:N/A nvidia-smi -a显示&#xff1a;CUDA Version: Not Found 解决方法 查看Nvidia驱动版本 nvidia-smi如下图&#xff0c;版本为530.41.03 搜索cuda库 apt search libcuda注&#xff1a;不同的源&#xff0c;同一个库的命…
阅读更多...
轻量级SQLite可视化工具Sqliteviz

轻量级SQLite可视化工具Sqliteviz

什么是 Sqliteviz &#xff1f; Sqliteviz 是一个单页面离线优先的渐进式网络应用&#xff08;PWA&#xff09;&#xff0c;用于完全客户端的 SQLite 数据库或 CSV 文件的可视化。 所谓完全客户端&#xff0c;就是您的数据库永远不会离开您的计算机。使用 sqliteviz&#xff0c…
阅读更多...
PyQt程序:实现新版本的自动更新检测及下载（FTP服务器实现）

PyQt程序:实现新版本的自动更新检测及下载（FTP服务器实现）

一、实现逻辑 本实例采用相对简单的逻辑实现，用户在客户端使用软件时点击“检测升级”按钮，连接至FTP服务器检索是否有新版本的.exe，如果有，下载最新的.exe安装升级。 本实例服务端待下载.exe所在目录结构 本实例客户端待更新.exe所在目录结构 二、搭建服务器 可以参考…
阅读更多...
IMUGNSS的误差状态卡尔曼滤波器（ESKF）的数学模型

IMUGNSS的误差状态卡尔曼滤波器（ESKF）的数学模型

IMU&GNSS的误差状态卡尔曼滤波器&#xff08;ESKF&#xff09;的数学模型 把IMU视为运动模型&#xff0c;把GNSS观测视为观测模型&#xff0c;推导整个滤波器 设状态变量为 x [ p , v , R , b g , b a , g ] T x[p,v,R,b_{g},b_{a},g]^{T} x[p,v,R,bg​,ba​,g]T 所有变…
阅读更多...
泛型的初步认识（2）

泛型的初步认识（2）

前言~&#x1f973;&#x1f389;&#x1f389;&#x1f389; hellohello~&#xff0c;大家好&#x1f495;&#x1f495;&#xff0c;这里是E绵绵呀✋✋ &#xff0c;如果觉得这篇文章还不错的话还请点赞❤️❤️收藏&#x1f49e; &#x1f49e; 关注&#x1f4a5;&#x…
阅读更多...
【深度学习实战（11）】搭建自己的dataset和dataloader

【深度学习实战（11）】搭建自己的dataset和dataloader

一、dataset和dataloader要点说明 在我们搭建自己的网络时&#xff0c;往往需要定义自己的dataset和dataloader&#xff0c;将图像和标签数据送入模型。 &#xff08;1&#xff09;在我们定义dataset时&#xff0c;需要继承torch.utils.data.dataset&#xff0c;再重写三个方法…
阅读更多...
LeetCode in Python 55. Jump Game (跳跃游戏)

LeetCode in Python 55. Jump Game (跳跃游戏)

跳跃游戏的游戏规则比较简单&#xff0c;若单纯枚举所有的跳法以判断是否能到达最后一个下标需要的时间复杂度为O()&#xff0c;为此&#xff0c;本文采用贪心策略&#xff0c;从最后一个下标开始逆着向前走&#xff0c;若能跳到第一个元素则表明可以完成跳跃游戏&#xff0c;反…
阅读更多...
Python基础学习之数据切片

Python基础学习之数据切片

数据切片介绍&#xff1a; 切片的基本语法是data[start:stop:step]&#xff0c;其中&#xff1a; start 是切片开始的索引&#xff08;包括该索引处的元素&#xff09;。 stop 是切片结束的索引&#xff08;不包括该索引处的元素&#xff09;。 step 是切片的步长&#xff0…
阅读更多...
Go小技巧易错点100例（十五）

Go小技巧易错点100例（十五）

本期看点&#xff1a; 正文开始&#xff1a; Go程序跟踪函数的执行时间 在Go程序中我们经常会对接口执行的耗时做一个记录&#xff0c;特别是针对核心或复杂业务的时候&#xff0c;我们需要关注该业务的执行耗时&#xff0c;可以具体到某个方法&#xff0c;有一个简单有效的技…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023