类和对象 封装 struct和class区别

已于 2023-03-28 22:26:32 修改
阅读量152 收藏 2
点赞数
分类专栏： c++ 文章标签： c++ java 算法 Powered by 金山文档
于 2023-03-24 13:57:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64005599/article/details/129723615
版权

封装意义：

struct和class的区别：

成员属性私有化：

优点1，控制成员的读写：
设置name可读可写：
#include<iostream>
#include<String>
using namespace std;
class Student {
public://公共方法赋值
    void setname(string name1)
    {
        name = name1;
    }
    string getname()
    {
        return name;
    }
private://私有属性，只有本类可用
    string name;
    int age;
    int passwad；
};
int main()
{
    Student s1;
    s1.setname("张");
    cout << "name：" << s1.getname() << endl;
}
设置age只读：
#include<iostream>
#include<String>
using namespace std;
class Student {
public:
    //设置姓名
    void setname(string name1)
    {
        name = name1;
    }
    //获取姓名
    string getname()
    {
        return name;
    }
    //获取年龄
    int getage()
    {
        int age = 18;
        return age;
    }

private:
    string name;//设置可读可写
    int age;//只读
    int passward;//只写


};
int main()
{
    Student s1;
    s1.setname("张");
    cout << "name：" << s1.getname() << endl;
    cout << "age:" << s1.getage();
}
设置password只写：
#include<iostream>
#include<String>
using namespace std;
class Student {
public:
    //设置姓名
    void setname(string name1)
    {
        name = name1;
    }
    //获取姓名
    string getname()
    {
        return name;
    }
    //获取年龄
    int getage()
    {
        int age = 18;
        return age;
    }
    //设置密码 只写 外界获取不到
    void setpassword(int password1)
    {
        password = password1;
    }
private:
    string name;//设置可读可写
    int age;//只读
    int password;//只写


};
int main()
{
    Student s1;
    s1.setname("张");
    cout << "name：" << s1.getname() << endl;
    cout << "age:" << s1.getage();
    //只可以设置 外界不可以获取
    s1.setpassword(123456);
    //cout << "password：" << s1.setpassword() << endl;
}
优点2，可以检测数据的有效性：
#include<iostream>
#include<String>
using namespace std;
class Student {
public:
    //设置姓名
    void setage(int age1)
    {   
        //检验年龄的有效性
        if (age1 < 0 || age1>150)
        {
            age = 0;
            cout << "你输入的年龄有误" << endl;
            return;
        }
        age = age1;
    }
    //获取年龄
    int getage()
    {    
        return age;
    }
private:
    string name;//设置可读可写
    int age;//只读
    int password;//只写
};
int main()
{
    Student s1;
    s1.setage(180);
//s1.setage（18）；
    cout << "年龄为：" << s1.getage() << endl;
}

练习案例1：

#include<iostream>
#include<String>
using namespace std;
class cube {
public:
    int caculateS(int c1, int w1, int h1)
    {
        return 2 * c1 * w1 + 2 * w1 * h1 + 2 * c1 * h1;
    }
    int caculateV(int c1, int w1, int h1)
    {
        return c1 * w1 * h1;
    }
    //行为：
    //设置获取长宽高
    void seth(int h1)
    {
        h = h1;
    }
    int geth()
    {
        return h;
    }
    void setw(int w1)
    {
        w = w1;
    }
    int getw()
    {
        return w;
    }
    void setc(int c1)
    {
        c = c1;
    }
    int getc()
    {
        return c;
    }

    bool isSameByClass(cube &c2)
    {
        if (c == c2.getc() && h == c2.geth() && w == c2.getw())
        {
            return true;
        }
        return false;
    }
//属性：
private:
    int h;
    int w;
    int c;
};
//全局函数判断
bool issame(cube &c1,cube &c2)
{
    if (c1.getc() == c2.getc() &&c1.geth( )==c2.geth()&&c1.getw()==c2.getw())
    {
        return true;
    }
        return false;
}

int main()
{
    cube c1;
    c1.setc(10);
    c1.setw(10);
    c1.seth(10);
    
    cout << "c1面积为：" << c1.caculateS(10,10,10) << endl;
    cout << "c1体积为：" << c1.caculateV(10,10,10) << endl;
    cube c2;
    c2.setc(10);
    c2.setw(10);
    c2.seth(5);

    //利用全局函数判断两个立方体是否相等
    bool result=issame(c1, c2);
    if (result)
    {
        cout << "c1,c2面积体积相同" << endl;
    }
    else {
        cout << "c1,c2面积体积不相同" << endl;
    }
    //利用成员函数判断两个立方体是否相等
    bool result1 = c1.isSameByClass(c2);
    if (result1)
    {
        cout << "成员函数，c1,c2面积体积相同" << endl;
    }
    else
    {
        cout << "成员函数，c1,c2面积体积不相同" << endl;
    }
}

练习案例2：

对象的初始化和清理：

构造函数和析构函数：

#include<iostream>
#include<string>
using namespace std;
class person
{
public:
    //1.构造函数
    //没有返回值 不用写void
    //函数名与类名相同
    //构造函数可以有参数，可以发送重载
    //创建对象的时候，构造函数会自动调用，而且只调用一次
    person()
    {
        cout << "person 构造函数的调用" << endl;
     }

};
    void test01()
   {
       person p; // 创建对象的时候，构造函数会自动调用，而且只调用一次
   }
int main()
{
    test01();
}

  1. 当person p；在全局区时
#include<iostream>
#include<string>
using namespace std;
class person
{
public:
    //1.构造函数
    //没有返回值 不用写void
    // 函数名与类名相同
    //构造函数可以有参数，可以发送重载
    //创建对象的时候，构造函数会自动调用，而且只调用一次
    person()
    {
        cout << "person 构造函数的调用" << endl;
     }
    //2.析构函数 进行清理的操作
    // 没有返回值 不写void
    // 函数名和类名相同 在名称前加~
    // 析构函数不可以有参数的，不可以发生重载
    // 对象在销毁前 会自动调用析构函数，而且只会调用一次
    ~person()
    {
        cout << "person 的析构函数" << endl;
    }
};
        void test01()
        {
            person p;
        }
int main()
{
    test01();
}
2.当person p；在main（）中：会等35行执行后，按任意键等所有程序结束，p被销毁后，析构函数自动调用
#include<iostream>
#include<string>
using namespace std;
class person
{
public:
    //1.构造函数
    //没有返回值 不用写void
    // 函数名与类名相同
    //构造函数可以有参数，可以发送重载
    // 创建对象的时候，构造函数会自动调用，而且只调用一次
    person()
    {
        cout << "person 构造函数的调用" << endl;
    }
    //2.析构函数 进行清理的操作
    // 没有返回值 不写void
    // 函数名和类名相同 在名称前加~
    // 析构函数不可以有参数的，不可以发生重载
    // 对象在销毁前 会自动调用析构函数，而且只会调用一次
    ~person()
    {
        cout << "person 析构函数的调用" << endl;
    }
};
    //构造和析构都是必须有的实现，如果我们自己不提供，编译器会提供一个空实现的构造和析构
    void test01()
    {
       person p;
    }
int main()
{
    person p;
    //test01();
    system("pause");
    return 0;
}

构造函数的分类及调用：

两种分类：
按照参数分类： 无参构造（默认构造）和有参构造
#include<iostream>
#include<string>
using namespace std;
class person {
public:
    //按照参数分类 无参构造（默认构造）和有参构造
    //无参构造函数
    person()
    {
        cout << "peroson的无参构造函数" << endl;
    }
    //有参构造函数
    person(int a)
    {
        cout << "peroson的有参构造函数" << endl;
    }
    //析构函数
    ~person()
    {
        cout << "person的析构函数" << endl;
    }


};
int main()
{
    
}
按照类型分类： 普通构造函数和拷贝构造函数
#include<iostream>
#include<string>
using namespace std;
class person {
public:
    //按照参数分类 无参构造（默认构造）和有参构造
    //无参构造函数
    person()
    {
        cout << "peroson的无参构造函数" << endl;
    }
    //有参构造函数
    person(int a)
    {   
        age = a;
        cout << "peroson的有参构造函数" << endl;
    }
    //析构函数
    ~person()
    {
        cout << "person的析构函数" << endl;
    }

    //拷贝构造函数
    person(const person &p)
    {
        age = p.age;
    }

    int age;

};
int main()
{
    
}
调用：
1括号法：
#include<iostream>
#include<string>
using namespace std;
class person {
public:
    //按照参数分类 无参构造（默认构造）和有参构造
    //无参构造函数
    person()
    {
        cout << "peroson的无参构造函数" << endl;
    }

    //有参构造函数
    person(int a)
    {   
        age = a;
        cout << "peroson的有参构造函数" << endl;
    }
    //拷贝构造函数
    person(const person &p)
    {
        age = p.age;
        cout << "peroson的拷贝构造函数" << endl;
    }
    //析构函数
    ~person()
    {
        cout << "person的析构函数" << endl;
    }

    int age;

};
void test01()
{

    //括号法
    person p1;//无参构造函数
    person p2(10);//有参构造函数
    person p3(p2);//拷贝构造函数

    cout << "p2的年龄" << p2.age << endl;
    cout << "p3的年龄" << p3.age << endl;

}
int main()
{
    test01();
    system("pause");
    return 0;
}
注意事项：
2.显示法：
#include<iostream>
#include<string>
using namespace std;
class person {
public:
    //按照参数分类 无参构造（默认构造）和有参构造
    //无参构造函数
    person()
    {
        cout << "peroson的无参构造函数" << endl;
    }

    //有参构造函数
    person(int a)
    {   
        age = a;
        cout << "peroson的有参构造函数" << endl;
    }
    //拷贝构造函数
    person(const person &p)
    {
        age = p.age;
        cout << "peroson的拷贝构造函数" << endl;
    }
    //析构函数
    ~person()
    {
        cout << "person的析构函数" << endl;
    }

    int age;

};
void test01()
{

    //括号法
    //person p1;//无参构造函数
    //person p2(10);//有参构造函数
    //person p3(p2);//拷贝构造函数

    //cout << "p2的年龄" << p2.age << endl;
    //cout << "p3的年龄" << p3.age << endl;
    //显示法
    person p1;
    person p2 = person(10);//有参构造函数
    person p3 = person(p2);//拷贝构造函数
    //person(10);
    //cout << "aaa" << endl;
}
int main()
{
    test01();
    system("pause");
    return 0;
}
注意事项2：匿名类
#include<iostream>
#include<string>
using namespace std;
class person {
public:
    //按照参数分类 无参构造（默认构造）和有参构造
    //无参构造函数
    person()
    {
        cout << "peroson的无参构造函数" << endl;
    }

    //有参构造函数
    person(int a)
    {   
        age = a;
        cout << "peroson的有参构造函数" << endl;
    }
    //拷贝构造函数
    person(const person &p)
    {
        age = p.age;
        cout << "peroson的拷贝构造函数" << endl;
    }
    //析构函数
    ~person()
    {
        cout << "person的析构函数" << endl;
    }

    int age;

};
void test01()
{
    person(10);//匿名对象：特点 这行执行结束后，系统会立即回收掉匿名对象
    cout << "aaa" << endl;
}
int main()
{
    test01();
    system("pause");
    return 0;
}
3隐式转换法：

拷贝构造函数的调用时机：

  1. 使用一个已经创建完毕的对象来初始话一个新对象
#include<iostream>
#include<string>
using namespace std;
class person {
public:
    //按照参数分类 无参构造（默认构造）和有参构造
    //无参构造函数
    person()
    {
        cout << "peroson的无参构造函数" << endl;
    }

    //有参构造函数
    person(int a)
    {   
        age = a;
        cout << "peroson的有参构造函数" << endl;
    }
    //拷贝构造函数
    person(const person &p)
    {
        age = p.age;
        cout << "peroson的拷贝构造函数" << endl;
    }
    //析构函数
    ~person()
    {
        cout << "person的析构函数" << endl;
    }

    int age;

};
void test01()
{
    //1. 使用一个已经创建完毕的对象来初始话一个新对象
    person p1(20);
    person p2(p1);
}
int main()
{
    test01();
}

  1. 值传递的方式给函数参数传值
#include<iostream>
#include<string>
using namespace std;
class person {
public:
    //按照参数分类 无参构造（默认构造）和有参构造
    //无参构造函数
    person()
    {
        cout << "peroson的无参构造函数" << endl;
    }

    //有参构造函数
    person(int a)
    {   
        age = a;
        cout << "peroson的有参构造函数" << endl;
    }
    //拷贝构造函数
    person(const person &p)
    {
        age = p.age;
        cout << "peroson的拷贝构造函数" << endl;
    }
    //析构函数
    ~person()
    {
        cout << "person的析构函数" << endl;
    }

    int age;

};
void dowork(person p)
{

}
void test02()
{
    //2.值传递的方式给函数参数传值
    person p;
    dowork(p);
}
int main()
{
    test02();
}
  1. 值方式返回局部对象：理解的一半
#include<iostream>
#include<string>
using namespace std;
class person {
public:
    //按照参数分类 无参构造（默认构造）和有参构造
    //无参构造函数
    person()
    {
        cout << "peroson的无参构造函数" << endl;
    }

    //有参构造函数
    person(int a)
    {   
        age = a;
        cout << "peroson的有参构造函数" << endl;
    }
    //拷贝构造函数
    person(const person &p)
    {
        age = p.age;
        cout << "peroson的拷贝构造函数" << endl;
    }
    //析构函数
    ~person()
    {
        cout << "person的析构函数" << endl;
    }

    int age;

};
person dowork()
{
    person p1;
    cout << (int*)&p1 << endl;
    return p1;
}
void test03()
{
    person p = dowork();
    cout << (int*)&p << endl;
}
int main()
{
    test03();
}

构造函数调用规则：

示例代码：
#include<iostream>
#include<string>
using namespace std;
class person {
public:
    //按照参数分类 无参构造（默认构造）和有参构造
    //无参构造函数
    person()
    {
        cout << "peroson的无参构造函数" << endl;
    }

    //有参构造函数
    person(int a)
    {   
        age = a;
        cout << "peroson的有参构造函数" << endl;
    }
    //拷贝构造函数
    person(const person &p)
    {
        age = p.age;
        cout << "peroson的拷贝构造函数" << endl;
    }
    //析构函数
    ~person()
    {
        cout << "person的析构函数" << endl;
    }
    int age;
};

void test01()
{
    person p;
    p.age = 18;
    cout << "p的年龄为" << p.age << endl;
}
int main()
{
    test01();
}
不对20-24行代码进行注释：
对20-24行代码进行注释：
说明：定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造
示例代码；
#include<iostream>
#include<string>
using namespace std;
class person {
public:
    //按照参数分类 无参构造（默认构造）和有参构造
    //无参构造函数
    //person()
    //{
        //cout << "peroson的无参构造函数" << endl;
    //}
    //有参构造函数
    person(int a)
    {   
        age = a;
        cout << "peroson的有参构造函数" << endl;
    }
    //拷贝构造函数
    person(const person &p)
    {
        age = p.age;
        cout << "peroson的拷贝构造函数" << endl;
    }
    //析构函数
    ~person()
    {
        cout << "person的析构函数" << endl;
    }

    int age;

};
void test01()
{
    //person p;//调用无参构造
    person p(29);//调用有参构造
    person p2(p);//调用拷贝构造
    cout << "p2的年龄为" << p2.age << endl;
}
}
int main()
{
    test01();
}
  1. 注释掉8-11行代码后，在35行调用无参构造运行报错，说明定义有参构造函数后，c++不在提供默认无参构造
2.注释掉19-23行代码后，在37行调用拷贝构造函数时，运行结构如下图，说明用户定义有参构造后，（不会提供默认构造），但是会提供默认拷贝构造函数，相当于编译器自动写了第21行的代码。
示例代码：
#include<iostream>
#include<string>
using namespace std;
class person {
public:
    //按照参数分类 无参构造（默认构造）和有参构造
    //无参构造函数
    //person()
    //{
        //cout << "peroson的无参构造函数" << endl;
    //}
    //有参构造函数
    //person(int a)
    //{   
        //age = a;
        //cout << "peroson的有参构造函数" << endl;
    //}
    //拷贝构造函数
    person(const person &p)
    {
        age = p.age;
        cout << "peroson的拷贝构造函数" << endl;
    }
    //析构函数
    ~person()
    {
        cout << "person的析构函数" << endl;
    }

    int age;

};
void test01()
{
    person p;
    person p(29);
    person p2(p);
    cout << "p2的年龄为" << p2.age << endl;
}
int main()
{
    test01();
}
3.注释掉7-17行代码后，运行报错，说明：定义构造函数之后，c++编译器不会在自动定义无参构造（默认构造）和有参构造

无危险
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中对面向对象、类、封装的理解
GAOGAOWQ的博客
05-26 180
面向过程指是：面对于一个问题的解决方案，不会做出重用的设计，而面向对象的主要设计方式 为模块化。 类是对某一类事物的共性的抽象概念，而对象描述的是一个具体的产物。JAVA类和对象的关系是：对象是类实例化出来的,对象中含有类的属性,类是对象的抽象。 在整个的面向对象的设计里面更多情况下的是标准。在使用的时候根据标准进行拼装， 而对于面向对象设计有三个主要特征： 1、封装性：内部的操作对外部而言不可见；当内部的操作都不可见的时候才安全。 2、继承性：在已有结构的基础上继续进行功能的扩充； ...
P99~105C++类和对象封装的学习笔记.docx
04-13
类和对象的封装也可以使用struct关键字来定义，struct和class的区别是，默认的访问权限不同，struct默认的访问权限是公共的，而class默认的访问权限是私有的。 ```cpp struct Person { string m_Name; // 姓名 ...
类与对象、封装
qq_25447799的博客
07-08 202
1. 面向对象概念 面向过程 强调的是过程(动作) C语言 面向对象 强调的是对象(实体) C++/ Java/C# 面向对象的特点： 1. 面向对象就是一种常见的思想。符合人们的思考习惯。 2. 面向对象的出现，将复杂的问题简单化。 3. 面向对象的出现，让曾经在过程中的执行者，变成了对象中的指挥者。 2. 类与对象之间的关系 用java语言对现实生活中的事物进行描述。通过类的形式来体现的。 2.1 怎么描述呢？ 对于事物描述通常只关注两方面。 一个是属性，一个是行为。 只要
类和对象的封装
qq_43718691的博客
03-03 628
C++面向对象的三大特性为：封装、继承、多态 C++认为万事万物都皆为对象，对象上有属性和行为 封装 一、封装的意义：封装是C++面向对象的三大特征之一 将属性和行为作为一个整体表现生活中的事物将属性和行为加以权限控制 封装的意义一：在设计的时候属性和行为写在一起表现事物 语法：class 类名{访问权限：属性/行为}； 封装意义二：类在设计是可以把属性和行为放在不同的权限加以控制 访问权限有三种： 1、public 公共权限（类内可以访问，类外也可以访问） 2、protected保护权
类和对象（封装）
qq_39768411的博客
07-15 782
c++面向对象的三大特性：封装，继承，多态。 c++认为万物皆为对象，对象上由属性和行为。 具有相同性质的对象，我们可以抽象为类。 封装：将属性和行为作为一个整体，表现生活中的事物；将属性和行为加以权限控制。 封装意义一：在设计类的时候，属性和行为写在一起，表现事物 语法：class类名{访问权限；属性/行为}； 类中的属性和行为统一称为成员 属性称为成员属性和成员变量 行为称为成员函数和成员方法 f 封装意义二： 1.public 公共权限 成员类内可以访问，
Java类和对象封装
weixin_44070116的博客
11-09 722
Java封装
C++封装例程(class,struct,public,protected,private,friend)
03-25
C++封装(class,struct,public,protected,private,friend)的博客例程。 https://blog.csdn.net/flysnow010/article/details/136907034
自己简单封装的一个CDialog类实例
01-01
本文实例讲述了自己简单封装的一个CDialog类实例。分享给大家供大家参考。具体如下： 该代码比较短小，实现了消息映射。 Dialog.h头文件如下: #include class CDialog { public: //一条消息所包含的信息 struct ...
用C语言实现面向对象编程
12-22
一、类的封装实现：借用高焕堂的宏... 　类的封装实质是用借用 struct 结构体，用函数指针来表示 C++中类的方法（成员函数）。接下来给类 A 的方法写实体函数。 void init_A(void *t，int x) { A *cthis = (A
Java自学——类与对象、封装
weixin_44378636的博客
11-27 196
类与对象、封装 面向对象思想 它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。 类的定义 类和对象 对象的使用 对象的内存图 类与对象的练习 成员变量与局部变量的区别 封装 概述 步骤 封装的操作——private 封装优化1——this关键字 封装优化2——构造方法 标准代码——JavaBean ...
4、类和对象—封装
weixin_44451178的博客
11-14 178
C++面向对象的三大特性为：封装、继承、多态 C++认为万事万物皆为对象，对象上有其属性和行为 具有相同性质的对象，我们可以抽象称为类 封装 封装的意义 封装是C++面向对象三大特性之一 封装的意义： 1、将属性和行为作为一个整体，表现生活中的事物 2、将属性和行为加以权限控制 封装的意义一： 在设计类的时候，属性和行为写在一起，表现事物 语法：class 类名{ 访问权限: 属性 / 行为 }; 示例1：设计一个圆类，求圆的周长 //设计一个圆类，求圆的周长 const double PI = 3.1
黑马程序员_JavaSE基础知识总结五：类与对象的区分及封装特性
liulin90的博客
11-12 429
------ android培训、java培训、期待与您交流！ ---------- “万物皆对象”是Java编程的核心思想，Java语言将对象视为奇特的变量，它可以存储数据，除此之外，你还可以要求它在自身上执行操作。用木匠打一个比方，一个“面向对象的”木匠始终关注的是所制作的椅子，第二位才是所使用的工具，面向对象编程思想的优势在于：①将复杂的事情简单化；②面向对象将以前的过程中的执
类和对象及封装的理解
空杯
12-29 1089
1.类 类是一组相关的属性和行为的集合。是一个抽象的概念。 对象是该类事物的具体表现形式。具体存在的个体。 2.封装 封装概述：是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。或者说指隐藏对象的属性和实现细节，仅对外提供公共访问方式。 封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。 适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。 封装好处： ·隐藏实现细节，提供公共的访问方式 ·提高了代码的复用性 ·提高安全性...
C++封装：类和对象
qq_42745340的博客
02-26 1419
2-1 C++类和对象 目的不同，抽象出的信息不同； 对象是具体的事物； 类是从对象中抽象出来的，出于不同的目的，同一事物可以被抽象为不同的类； 封装：把实现细节封装起来，只暴露给用户关心的部分； 怎么实现希望暴露和希望隐藏：访问限定符； 扩展：结构体和类的区别： 1.语法定义上的区别：定义类使用关键字class 定义结构使用关键字struct； 2.结构体中声明的字段无法赋予初...
类与对象（封装）
sophie1314的博客
11-22 900
类是生产对象的蓝图，首先生产类，才可以产生对象。对象的所有行为，一定在类中进行了完整的定义。 类的语法： class 类名称{ 属性1； 属性2； 属性n...； 方法1(){} 方法2(){} 方法n(){}... } 以上就是一个类的完整定义，此时的方法不再由主类直接调用，而是需要有对象调用。类有一定的设计原则，我们通过下面的说明和例子来一一深入。...
对象封装和类--详解
sxzhliang的专栏
10-22 1264
          面向对象思想有三个核心要素：封装、继承与多态。如能正确理解这三要素，那么基本上可以算是在编程中建立了面向对象思想。在第二节中我曾介绍，在C#中， 所有数据类型的实例都是“对象”，不过最能体现对象特质的类型，还是“类”，同时它也是C#中最重要、最频繁使用的类型。接下来，我将通过介绍C#的类， 来充分理解对象封装的概念。 　　所谓“对象”，形象地说，我们可以把它理解为一块积木。设计
【C++笔记】封装的意义，结构体和类的区别
Huffie博客
03-05 679
封装的意义将属性和行为作为一个整体，表现生活中的事物；将属性和行为加以权限控制。设计类时，属性和行为写在一起，表现事物，语法规范如下
【C++】——Stack与Queue（含优先队列（详细解读）
最新发布
m0_74092462的博客
06-09 981
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
结构struct和类class有什么异同
06-11
结构(struct)和类(class)在 C++ 中都是用来实现自定义类型的关键字，它们的异同点如下： 1. 相同点： - 都可以包含成员变量和成员函数。 - 都可以进行继承。 - 都可以定义构造函数和析构函数。 2. 不同点： - 类(class)默认成员访问权限为 private，而结构体(struct)默认成员访问权限为 public。 - 类(class)可以定义访问控制符(private, protected, public)，结构体(struct)不能定义访问控制符。 - 类(class)支持数据封装和抽象，而结构体(struct)不支持。 一般来说，如果只是用来存储数据的话，可以使用结构体(struct)；如果需要进行面向对象的编程，定义类(class)更为方便，因为类(class)可以更好地支持数据封装和抽象。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值