DAY03 类与对象

news2024/11/10 15:37:30

概述

对象:真实存在的事物 

类:

        多个对象抽取其共同点形成的概念
        静态特征提取出的概念称为成员变量, 又名属性
        动态特征提取出的概念称为成员函数, 又名方法
类与对象的关系
        在代码中先有类后有对象
        一个类可以有多个对象
        多个对象可以属于同一个类

类的定义

语法

class 类名
{
        [访问权限修饰符 :]
        成员变量
        成员函数
};

访问权限修饰符

private 私有的 , 当前类中可用 , 默认的
protected 受保护的 , 当前类或子类中可用
public 公共的 , 当前项目中可用

示例

class Person{
private:
    int age;
protected:
    char sex[10];
public:
    char name[50];
    void eat()
    {
        cout << name << "吃饭" << endl;
    }
    void sleep();
};
void Person::sleep()
{
    cout << name << "睡觉" << endl;
}

类的对象

概念

        类定义好之后, 可以通过类,创建具体的对象,创建的类的对象又称之为类的实例。
通过类创建的对象,对象即具有类的属性(数据)和方法         

语法

实例化对象
        类名 对象名;
操作其中的成员
        获取属性值
                对象名.属性名 ;
        修改属性值
                对象名.属性名 = ;
        调用函数
                对象名.函数名 ( 实参列表 );
注意 :
        以上对操作的成员, 必须在访问权限修饰符上得以满足
如在类外不能直接使用私有成员

示例

int main(int argc, char *argv[])
{
Person p1;
strcpy(p1.name,"张三");
p1.eat();
p1.sleep();
return 0;
}

封装性

即包装 , 将数据和方法封装在一起 , 加以权限区分使其可以保护内部 , 降低耦合度 , 便于使
int a = 10;
int nums[5] = {1,2,3,4,5};
void fun()
{
    xxx
}
class A
{
    属性
    函数
}
A a;
x.c
优点 :
        1,降低代码耦合度
        2,提高代码复用率
        3,编译使用

类的设计

1, 私有化所有属性
2, 提供可以获取这些属性值与修改属性值的函数

示例:

class Stu
{
private:
    char name[50];
    char sex[10];
    int age;
public:
    char* get_name()
    {
        return name;
    }
    void set_name(char* n)
    {
        strcpy(name,n);
    }
    char* get_sex()
    {
        return sex;
    }
    void set_sex(char* s)
    {
        strcpy(sex,s);
    }
    int get_age()
    {
        return age;
    }
    void set_age(int a)
    {
        age = a;
    }
    void print_info()
    {
        cout << "姓名:" << name << "\t性别:" << sex << "\t年龄:" << age << endl;
    }
};
int main(int argc, char *argv[])
{
    Stu s;
    s.set_name("张三");
    s.set_sex("男");
    s.set_age(18);
    s.print_info();
    cout << s.get_name() << endl;
    cout << s.get_sex() << endl;
    cout << s.get_age() << endl;
    return 0;
}

构造函数

概念

构造函数 是类实例化对象的时候自动调用。
注意 :
        当一个类中没有构造函数, 系统将默认为其生成一个无参构造如果一个类中有构造函数, 系统将不会为其提供默认的无参构造一个类可以定义多个构造函数, 该类中的多个构造函数为重载关系
无参构造 :
        构造函数无形参列表
有参构造 :
        构造函数有形参列表

语法

类名 ( 形参列表 )
{
        该类对象赋初始值
}
注意 : 形参列表可有可无

示例

class Dog
{
private:
    char name[50];
    int age;
public:
    Dog()
    {
        cout << "调用无参构造" << endl;
    }
    Dog(char *n,int a)
    {
        cout << "调用有参构造" << endl;
        strcpy(name,n);
        age = a;
    }
    Dog(char *n)
    {
        cout << "调用一参构造" << endl;
        strcpy(name,n);
    }
};
int main(int argc, char *argv[])
{
//隐式调用无参构造创建对象
Dog d1;
//显式调用无参构造创建对象
Dog d2 = Dog();
//隐式调用有参构造创建对象
Dog d3("旺财",2);
//显式调用有参构造创建对象
Dog d4 = Dog("富贵",1);
//如果构造函数只有一个参数,会发生构造函数的隐式转换(知道就行)
//隐式转换
//类名 对象名 = 值;
Dog d5 = "黑豹";
//匿名对象:创建的对象没有对象名
Dog();
Dog("无名");
return 0;
}

析构函数

概念

对象生命周期结束的时候 自动调用析构函数。
注意 :
        一个类只能有一个析构函数
        如果用户不提供析构函数 编译器默认会提供一个空的析构函数。
经验 :
        一般不需要自定义析构函数, 但是如果类中有指针成员且指向堆区空间,这时必须实现析构函数, 在其中释放指针成员指向的堆区空间

语法

~ 类名 ()
{
}
注意 : 没有形参列表

示例

class Cat{
private:
    char name[50];
public:
    Cat(char *n)
    {
        strcpy(name,n);
        cout << name << "被创建了" << endl;
    }
    ~Cat()
    {
        cout << name << "被销毁了" << endl;
    }
};
void test01()
{
    Cat c("布丁");
}
int main(int argc, char *argv[])
{
    test01();
    return 0;
}

多对象构造与析构顺序

示例 1: 对象 A 与对象 B 平级 , 符合栈的顺序 ( 先进后出 ), 谁先创建谁后释放
class Cat{
private:
    char name[50];
public:
    Cat(char *n)
    {
        strcpy(name,n);
        cout << name << "被创建了" << endl;
    }
    ~Cat()
    {
        cout << name << "被销毁了" << endl;
    }
};
void test01()
{
    Cat c1("布丁");
    Cat c2("乔巴");
    {
        Cat c3("可乐");
        Cat c4("雪碧");
    }
}
int main(int argc, char *argv[])
{
    test01();
    return 0;
}

结果:

示例 2: 对象 A 是对象 B 的成员 , 先成员构造 , 在对象构造 , 在对象析构 , 在成员析构
class A{
public:
A(){
    cout << "A构造" << endl;
}
~A()
{
    cout << "A析构" << endl;
}
};
class B{
private:
    A a;
public:
B(){
    cout << "B构造" << endl;
}
~B()
{
    cout << "B析构" << endl;
}
};
int main(int argc, char *argv[])
{
    B b;
    return 0;
}

拷贝构造函数

概述

拷贝构造在以下情况自动触发 :
        1,旧对象给新对象初始化 , 会调用拷贝构造函数
        2,对象作为函数的形参 , 函数调用时会调用拷贝构造
        3,普通对象作为函数的返回值 (vs 会触发拷贝构造 ,Qt Linux 不会触发拷贝构造 )
注意 :
        如果用户不提供拷贝构造 编译器会提供一个默认的拷贝构造(浅拷贝)。
        只有类中有指针成员且指向堆区时 才有必要实现拷贝构造(深拷贝)。
浅拷贝与深拷贝
        浅拷贝: 当类中的成员有指针成员 , 此时只拷贝地址
        深拷贝: 当类中的成员有指针成员 , 先开辟内存 ,在拷贝其值        

语法

类名 (const 类名 &ob)
{
}

示例

示例 1: 旧对象给新对象初始化
class Cat{
private:
char name[50];
public:
Cat(char *n)
{
strcpy(name,n);
cout << name << "被创建了" << endl;
}
~Cat()
{
cout << name << "被销毁了" << endl;
}
Cat(const Cat &cat)
{
cout << "拷贝构造被调用了" << endl;
strcpy(name,cat.name);
}
};
int main(int argc, char *argv[])
{
Cat c1("布丁");
Cat c2 = c1;
return 0;
}
示例 2: 对象作为函数的形参 , 函数调用时会调用拷贝构造
class Cat{
private:
    char name[50];
public:
    Cat(char *n)
    {
        strcpy(name,n);
        cout << name << "被创建了" << endl;
    }
    ~Cat()
    {
        cout << name << "被销毁了" << endl;
    }
    Cat(const Cat &cat)
    {
        cout << "拷贝构造被调用了" << endl;
        strcpy(name,cat.name);
    }
};
void test(Cat cat)
{
}
int main(int argc, char *argv[])
{
    Cat c1("布丁");
    test(c1);
    return 0;
}
示例 3: 普通对象作为函数的返回值 (vs 会触发拷贝构造 ,Qt Linux 不会触发拷贝构造 )
class Cat{
private:
    char name[50];
public:
Cat(char *n)
{
strcpy(name,n);
cout << name << "被创建了" << endl;
}
~Cat()
{
cout << name << "被销毁了" << endl;
}
Cat(const Cat &cat)
{
cout << "拷贝构造被调用了" << endl;
strcpy(name,cat.name);
}
};
Cat test()
{
Cat c1("布丁");
return c1;
}
int main(int argc, char *argv[])
{
Cat c = test();
return 0;
}

浅拷贝

class Cat{
public:
char *name;
Cat(char *n)
{
name = n;
cout << name << "被创建了" << endl;
}
~Cat()
{
cout << name << "被销毁了" << endl;
}
};
int main(int argc, char *argv[])
{
char name[10] = "Hi";
Cat c1(name);
Cat c2 = c1;
c2.name[0] = 'h';
cout << "c1.name = " << c1.name << endl;
cout << "c2.name = " << c2.name << endl;
return 0;
}

深拷贝

class Cat{
public:
    char *name;
Cat(char *n)
{
    name = (char *)calloc(1,50);
    strcpy(name,n);
    cout << name << "被创建了" << endl;
}
~Cat()
{
    cout << name << "被销毁了" << endl;
    free(name);
}
Cat(const Cat &cat)
{
    name = (char *)calloc(1,50);
    strcpy(name,cat.name);
}
};
int main(int argc, char *argv[])
{
    char name[10] = "Hi";
    Cat c1(name);
    Cat c2 = c1;
    c2.name[0] = 'h';
    cout << "c1.name = " << c1.name << endl;
    cout << "c2.name = " << c2.name << endl;
    return 0;
}

初始化列表

概述

构造函数 : 主要用于创建类的对象是给其属性赋初始值
在定义构造函数时, C++ 中提供了初始化列表的语法 , 以便于初始化成员变量的值。

语法

类名 ( 参数列表 ): 成员名 ( 参数名 ), 成员名 2( 参数名 2),... {
}

示例

示例1

class Data
{
    int a;
    int b;
public:
Data(int x,int y):b(y),a(x)
{
}
void print_data()
{
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
}
};
int main(int argc, char *argv[])
{
    Data d(10,1);
    d.print_data();
    return 0;
}

explicit关键字

作用

禁止隐式转换

语法

explicit 类名 ( 形参列表 ): 初始化列表
{
}

示例

class C{
private:
int a;
public:
explicit C(int x):a(x){}
};
int main(int argc, char *argv[])
{
C c = 10;//构造函数的隐式转换
//当调用构造函数使用explicit修饰后防止隐式转换,此时上述代码报错
return 0;
}

new与delete

情况 1: 操作基本类型
作用
new 申请堆区空间
delete 释放堆区空间。
示例:
void fun01()
{
int *p1 = new int;
*p1 = 100;
cout << *p1 << endl;
int *p2 = new int(100);//给p2的值初始化为100
cout << *p2 << endl;
}
情况 2: 操作数组
作用:
new 申请堆区空间
delete 释放堆区空间。
示例:
void fun02()
{
int *nums = new int[5];
cout << nums[0] << "\t" << nums[1] << endl;
delete [] nums;
int *ns = new int[5]{11,22,33,44,55};
cout << ns[0] << "\t" << ns[1] << endl;
delete [] ns;
}
情况 3: 操作对象
作用:
new: 分配空间 , 调用构造函数
delete: 调用析构函数 , 释放空间
示例:
class D{
public:
D(){
cout << "D构造" << endl;
}
~D(){
cout << "D析构" << endl;
}
};
void fun03()
{
D *d = new D();
delete d;
}

注意:

malloc,calloc,free 只能申请或释放空间 , 不能调用构造函数或析构函数
new,delete, 既能申请或释放空间 , 又能调用构造函数或析构函数
所以建议不要使用 malloc,calloc,free 等函数了

对象数组

静态对象数组
示例:
class A
{
public:
int mA;
public:
A()
{
cout<<"A无参构造"<<endl;
}
A(int a)
{
mA = a;
cout<<"A有参构造mA="<<mA<<endl;
}
~A()
{
cout<<"A析构函数mA="<<mA<<endl;
}
};
void fun04()
{
//对象数组 必须显示调用构造函数初始化
A arr[5]={A(10),A(20),A(30),A(40),A(50)};
int n = sizeof(arr)/sizeof(arr[0]);
int i=0;
for(i=0;i<n;i++)
{
cout<<arr[i].mA<<" ";
}
cout<<endl;
}
动态对象数组
示例:
void fun05()
{
A *arr = new A[5]{A(10),A(20),A(30),A(40),A(50)};
int i=0;
for(i=0;i<5;i++)
{
cout<<arr[i].mA<<" ";
}
cout<<endl;
//delete arr;//只会释放第0个元素
delete [] arr;
}

静态成员

静态成员变量
概述:
        static修饰的成员为静态成员。
特点 :
        静态成员是属于类而不是对象。(所有对象共享)
注意 :
        静态成员数据不占对象的内存空间。
        静态成员数据是属于类 而不是对象(多有对象共享一份静态成员数据)
        静态成员数据在定义对象之前就存在。静态成员数据在类中定义, 类外初始化。
示例:
class E{
public:
static int num;//类中定义静态成员
};
int E::num = 100;
int main(int argc, char *argv[])
{
//使用类名访问
cout << "E::num = " <<E::num << endl;
E e1;
E e2;
//使用对象名访问
cout << "e1.num = " <<e1.num << endl;
cout << "e2.num = " <<e2.num << endl;
e1.num = 1;
//一个对其修改该类所有对象的静态成员都将被修改
cout << "E::num = " <<E::num << endl;
cout << "e1.num = " <<e1.num << endl;
cout << "e2.num = " <<e2.num << endl;
return 0;
}

静态成员函数

概述:

使用 static 修饰的成员函数
特点 :
静态成员函数只能访问静态成员数据
示例:
class E{
private:
static int num;//类中定义静态成员
int x;
public:
static void set_num(int n)
{
num = n;
cout << "静态函数set_num被执行" << endl;
}
static int get_num()
{
cout << "静态函数get_num被执行" << endl;
return num;
}
};
int E::num = 100;
int main(int argc, char *argv[])
{
//使用类名调用
E::set_num(10);
int x = E::get_num();
//使用对象调用
E e;
e.set_num(1);
return 0;
}

单例模式

概述
所属的类 只能实例化一个对象。
示例 : 懒汉式
class DL{
private:
static DL *dl;
DL(){}
DL(const DL &d){}
public:
int x;
static DL* get_instance()
{
if(dl == NULL)
{
dl = new DL();
}
return dl;
}
};
DL *DL::dl = NULL;
int main(int argc, char *argv[])
{
DL *d1 = DL::get_instance();
DL *d2 = DL::get_instance();
DL *d3 = DL::get_instance();
d1->x = 1;
d2->x = 10;
d3->x = 100;
cout << "d1.x = " << d1->x << endl;
cout << "d2.x = " << d2->x << endl;
cout << "d3.x = " << d3->x << endl;
return 0;
}
示例 : 饿汉式
class DL{
private:
static DL *dl;
DL(){}
DL(const DL &d){}
public:
int x;
static DL* get_instance()
{
return dl;
}
};
DL *DL::dl = new DL();
int main(int argc, char *argv[])
{
DL *d1 = DL::get_instance();
DL *d2 = DL::get_instance();
DL *d3 = DL::get_instance();
d1->x = 1;
d2->x = 10;
d3->x = 100;
cout << "d1.x = " << d1->x << endl;
cout << "d2.x = " << d2->x << endl;
cout << "d3.x = " << d3->x << endl;
return 0;
}

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

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

相关文章

同城跑腿服务预约小程序的作用是什么

随着生活质量逐渐提升&#xff0c;围绕人们生活的行业或产品非常多&#xff0c;同时互联网赋能下&#xff0c;也出现了很多便捷人们日常消费的场景&#xff0c;如外卖服务、快递服务等。 跑腿仅依赖微信私聊及电话预约是很低效且容易出错及造成极大工作压力的&#xff0c;同时…

深度学习人体跌倒检测 -yolo 机器视觉 opencv python 计算机竞赛

0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; **基于深度学习的人体跌倒检测算法研究与实现 ** 该项目较为新颖&#xff0c;适合作为竞赛课题方向&#xff0c;学长非常推荐&#xff01; &#x1f947;学长这里给一个题目综合评分(每项满…

内网穿透的应用-如何在Docker中部署MinIO服务并结合内网穿透实现公网访问本地管理界面

文章目录 前言1. Docker 部署MinIO2. 本地访问MinIO3. Linux安装Cpolar4. 配置MinIO公网地址5. 远程访问MinIO管理界面6. 固定MinIO公网地址 前言 MinIO是一个开源的对象存储服务器&#xff0c;可以在各种环境中运行&#xff0c;例如本地、Docker容器、Kubernetes集群等。它兼…

企业微信机器人定时发送图文信息,后续无需人工操作

企业微信群机器人是企业微信的内置功能&#xff0c;可以理解为是一个群提醒通知工具&#xff0c;接收数据并自动发送信息到企业微信群中。 数环通实现打通定时器和企业微信机器人的对接&#xff0c;定时执行自动化流程&#xff0c;无需人工干预&#xff0c;实现工作流程自动化&…

大型 APP 的性能优化思路

做客户端开发都基本都做过性能优化&#xff0c;比如提升自己所负责的业务的速度或流畅性&#xff0c;优化内存占用等等。但是大部分开发者所做的性能优化可能都是针对中小型 APP 的&#xff0c;大型 APP 的性能优化经验并不会太多&#xff0c;毕竟大型 APP 就只有那么几个&…

UE 材质,如何只取0~1之间的值,其余值抛弃

假如0~1&#xff0c;floor为0&#xff0c;abs为0&#xff0c;Saturate为0&#xff0c;1-x为1&#xff0c;很好 假如1~2&#xff0c;floor为1&#xff0c;abs为1&#xff0c;Saturate为1&#xff0c;1-x为0&#xff0c;很好 假如2~3&#xff0c;floor为2&#xff0c;abs为2&am…

拼多多API接口,百亿补贴商品详情接口系列

随着互联网的快速发展&#xff0c;电子商务在日常生活中扮演着越来越重要的角色。拼多多&#xff0c;作为中国领先的社交电商巨头&#xff0c;以其独特的商业模式和创新的API接口&#xff0c;为广大开发者提供了一个全新的电商生态系统。本文将详细介绍拼多多的API接口及其应用…

打印工具HandyPrint Pro Mac中文版软件特点

HandyPrint Pro Mac是一款打印工具&#xff0c;它支持AIrPrint协议&#xff0c;可以让用户在iPhone、iPad、iPod等设备上进行打印操作&#xff0c;只需要将这些设备连接到Mac电脑的WiFi网络中即可实现打印功能。 ​ HandyPrint Pro Mac软件特点 简单易用&#xff1a;用户只需…

汽车级全保护型六路半桥驱动器NCV7708FDWR2G 原理、参数及应用

NCV7708FDWR2G 是一款全保护型六路半桥驱动器&#xff0c;特别适用于汽车和工业运动控制应用。六个高压侧和低压侧驱动器可自由配置&#xff0c;也可单独控制。因此可实现高压侧、低压侧和 H 桥控制。H 桥控制提供正向、逆向、制动和高阻抗状态。驱动器通过标准 SPI 接口进行控…

极速进化,融合“新“生 | StarRocks Summit 2023 技术交流峰会圆满落幕

2023年11月17日&#xff0c;由 StarRocks 社区发起、镜舟科技主办的 StarRocks 年度大型技术交流峰会 StarRocks Summit 2023 在上海成功举行。 本次峰会以「极速进化&#xff0c;融合"新"生」为主题&#xff0c;40余场分享演讲在全天密集开展&#xff0c;来自平安银…

软件项目可行性研究报告

一、可行性研究报告 1.1编写目的 1.2项目背景 1.3定义 1.4参考资料 2&#xff0e;可行性研究的前提 2.1要求 2.2目标 2.3条件、假定和限制 2.4可行性研究方法 2.5决定可行性的主要因素 3&#xff0e;对现有系统的分析 3.1处理流程和数据流程 3.2工作负荷 3.3费用…

阿里云ack集群升级流程

最近一直在升级过期的ack 集群版本 从1.22升级到1.24.。 参考&#xff1a; 升级流程、方式及所需时间

LeetCode207.课程表

看完题我就想&#xff0c;这不就是进程里面的死锁问题嘛&#xff0c;进程1等进程2释放锁&#xff0c;进程2等进程3释放锁&#xff0c;进程3等进程1释放锁&#xff0c;这就造成了死锁。或者是spring中的循环依赖问题&#xff0c;BeanA的初始化需要初始化一个BeanB&#xff0c;Be…

php 时区查看和设置

php的时区&#xff0c;关系到相关时间函数的结果 其他相关&#xff1a; linux时区设置&#xff1a;链接 pgsql时区设置&#xff1a; 一、查看可以用的时区列表 新建一个php文件&#xff0c;输入下面程序即可 <?php echo "<pre>"; var_dump(timezone_id…

时间序列预测(8) — Informer模型原理

目录 0 摘要 1 引言 2 定义 3 方法 3.1 高效的自注意力机制 3.2 稀疏度度量 3.3 ProbSparse稀疏自注意力机制 3.4 Encoder编码器 3.5 Decoder解码 参考视频&#xff1a;Informer原理及代码解析_哔哩哔哩_bilibili 0 摘要 长序列时间序列预测&#xff08;LSTF&#x…

算法-二叉树-简单-二叉树的最大和最小深度

记录一下算法题的学习7 二叉树的最大深度 题目&#xff1a;给定一个二叉树 root &#xff0c;返回其最大深度。 二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。 输入&#xff1a;root [3,9,20,null,null,15,7] 输出&#xff1a;3 示例分析&#xff…

计算机毕业设计选题推荐-家庭理财微信小程序/安卓APP-项目实战

✨作者主页&#xff1a;IT研究室✨ 个人简介&#xff1a;曾从事计算机专业培训教学&#xff0c;擅长Java、Python、微信小程序、Golang、安卓Android等项目实战。接项目定制开发、代码讲解、答辩教学、文档编写、降重等。 ☑文末获取源码☑ 精彩专栏推荐⬇⬇⬇ Java项目 Python…

如何进行手动脱壳

脱壳的目的就是找到被隐藏起来的OEP&#xff08;入口点&#xff09; 这里我一共总结了三种方法&#xff0c;都是些自己的理解希望对你们有用 单步跟踪法 一个程序加了壳后&#xff0c;我们需要找到真正的OEP入口点&#xff0c;先运行&#xff0c;找到假的OEP入口点后&#x…

Java零基础-Maven项目构建(最详细)

【Maven】 1.当前开发中存在的问题 1.1. 一个项目就是一个工程 如果项目非常庞大,就不适合继续使用package划分模块.最好是每一个模块对应一个项目,利于分工协作,也利于项目针对性能化的部署. 1.2. 项目中需要的jar包必须拷贝 项目中的jar包需要手动"复制" "粘…

定时关机软件哪个好?定时关机软件大盘点

在生活和工作中&#xff0c;我们可以使用定时关机软件来定时关闭电脑&#xff0c;以实现对电脑的控制。那么&#xff0c;定时关机软件哪个好呢&#xff1f;下面我们就来了解一下。 定时关机软件的作用 定时关机软件可以帮助用户在预设的时间自动关闭电脑。这对于那些需要在特…