C++中的类详解（1）

已于 2022-08-16 14:57:42 修改
阅读量765 收藏 16
点赞数 2
分类专栏： C++学习 文章标签： c++ 开发语言
于 2022-08-07 21:47:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DUANJIAWEIDUANJIAWEI/article/details/126201105
版权

c++中的类详解

知识点1【封装】

  1. 把变量和函数合成一个整体，封装在一个类中
  2. 对变量和函数进行访问控制（公有、私有、保护）
访问属性属性对象内部对象外部
public公有可访问可访问
protected保护可访问不可访问
private私有可访问不可访问

在没有涉及继承与派生时，protected与private 是同等级的，外部不允许访问。

知识点2【类的初识】

#include <iostream>
#include<cstring>
using namespace std;
class Person{
private:
    char name[20];//定义类的时候，不要给成员初始化
    int age;
public:
    void setNmae(char* n){
        strcpy(name,n);
    }
    char* getName(){
        return name;
    }
    void setAge(int a){
        age = a;
    }
    int getAge(){
        return age;
    }
};

int main(int argc, char *argv[])
{
    Person person;
    char name[20] = "tony";
    person.setNmae(name);
    person.setAge(15);
    cout << person.getName() << person.getAge() << endl;
    return 0;
}

实例：设计一个点和圆的类

#include <iostream>

using namespace std;
class Point{//设计一个点的类
private:
    int m_x;
    int m_y;
public:
    void setX(int x){
        m_x = x;
    }
    int getX(){
        return m_x;
    }
    void setY(int y){
        m_y = y;
    }
    int getY(){
        return m_y;
    }
};

class Circle{//设计一个圆的类
private:
    Point point;
    int r;
public:
    void setPoint(int x,int y){
        point.setX(x);
        point.setY(y);
    }

    void setR(int x){
        r = x;
    }
    void isPointOnCircle(Point &ob){
        //判断点与圆的关系
        int distance = (point.getX()-ob.getX()) *(point.getX()-ob.getX()) + (point.getY() - ob.getY()) * (point.getY() - ob.getY());
        if(distance > r*r){
            cout << "在圆外" << endl;
        }else if(distance == r*r){
            cout << "在圆上" << endl;
        }else{
            cout << "在圆内" << endl;
        }
    }

};

int main(int argc, char *argv[])
{
	//实例化一个点对象
    Point p1;
    p1.setX(5);
    p1.setY(5);
    
    //实例化一个圆对象
    Circle circle;
    circle.setR(3);
    circle.setPoint(3,3);
    //判断点point与圆的关系
    circle.isPointOnCircle(p1);
    return 0;
}

知识点3【类的空间大小】

成员数据占类的空间大小，成员函数不占类空间的大小。

using namespace std;
 class Data
 {
 private:
 //成员数据 占类的空间大小
 int num;//4B
 public:

 //成员函数 不占类的空间大小
 void setNum(int data)
 {
 num = data;
 }
 int getNum(void)
 {
 return num;
 }
 };
 void test01()
 {
 printf("%d\n",sizeof(Data));//4B
 }

知识点4【在类内声明 类外定义 成员函数】

class data{
private:
    int num;
public:
    void setNum(int x);
    int getNum();
};

void Data::setNum(int x){
     num = x;
 }
 
int Data::getNum(){
     return num;
 }

void test01(){
     Data data;
     data.setNum(100);
     cout << data.getNum() << endl;
 }
int main(int argc, char *argv[]){
    test01();
    return 0;
}

知识点5【类的定义在头文件 成员函数 在cpp文件中实现】

data1.h

#ifndef DATA1_H
#define DATA1_H


class Data1
{
private:
    int num;
public:
    void setNum(int x);
    int getNum();
};

#endif // DATA1_H

data1.cpp

#include "data1.h"

void Data1::setNum(int x){
    num = x;
}

int Data1::getNum(){
    return num;
}

main.cpp

#include <iostream>
#include"data1.h"

using namespace std;

void test01(){
     Data1 data;
     data.setNum(1000);
     cout << data.getNum() << endl;
 }

int main(int argc, char *argv[]){
    test01();
    return 0;
}

知识点6【构造和析构函数的概述】

构造函数和析构函数都会被编译器自动调用，构造函数完成对象的初始化动作，析构函数在对象结束的时候完成清理工作。

注意：初始化和清理工作是编译器强制我们做的事情，即使程序并没有提供初始化操作和清理操作，编译器也会给程序增加默认的操作，但是默认操作并不会做任何事。

构造函数：实例化对象的时候系统自动调用
析构函数：对象释放的时候系统自动调用

知识点7【构造和析构函数的定义】

构造函数的语法：
构造函数名与类名相同，没有返回类型，连void都不可以，但可以有参数，可以重载。
析构函数的语法:
析构函数的名字是在类名前面加“ ~ ”组成，没有返回类型，连void都不可以，不能有参数，不能重载。
案例：

#include <iostream>

using namespace std;

class Data
{
public:
    Data() {
        cout << "无参构造函数" << endl;
    }

    Data(int num){
        num = 100;
        cout << "有参构造函数" << endl;
    }

    ~Data(){
        cout << "析构函数" << endl;
    }
};

int main(int argc, char *argv[])
{
    cout << "-----------01----------" << endl;
    Data ob;
    cout << "-----------02----------" << endl;
    return 0;
}

知识点8【构造函数的分类以及调用】

1、构造函数的分类

按参数类型分类： 分为无参构造函数和有参构造函数
按类型分类：普通构造函数和拷贝构造函数（复制构造函数）

2、构造函数的调用

#include <iostream>

using namespace std;

class Data
{
private:
    int num;
public:
    Data() {
        num = 0;
        cout << "无参构造函数" << endl;
    }

    Data(int num1){
        num = num1;
        cout << "有参构造函数" << num << endl;
    }

    ~Data(){
        cout << "析构函数" << num << endl;
    }
};
void test01(){
    //调用无参或默认构造函数
    Data ob;
    //调用有参构造函数（显式调用）
    Data ob1 = Data(100);
    //调用有参构造函数（隐式调用）
    Data ob2(1000);
    //隐式转换的方式 调用有参构造（针对于 只有一个数据成员）（尽量别用)
    Data ob3 = 10000;//转化成Data ob5(30)

    //匿名对象(当前语句结束 匿名对象立即释放)
    Data(40);
    cout << "---------------------" << endl;

    //千万不要 用以下方式调用 无参构造
    //Data ob4();//不会被认为时实例化对象，会被看作函数ob4的声明
}

int main(int argc, char *argv[])
{
    cout << "-----------01----------" << endl;
    test01();
    cout << "-----------02----------" << endl;
    return 0;
}

在这里插入图片描述
注意：在同一作用域，构造和析构的顺序相反（类似于栈，先进后出）

3、拷贝构造函数（系统提供一个拷贝构造函数 赋值操作）

#include <iostream>

using namespace std;

class Data
{
public:
    int num;
public:
    Data() {
        num = 0;
        cout << "无参构造函数" << endl;
    }

    Data(int num1){
        num = num1;
        cout << "有参构造函数" << num << endl;
    }

    //拷贝构造函数
    Data(const Data &ob){//Data &ob = ob5;
        num = ob.num;
        cout << "拷贝构造函数" <<endl;
    }

    ~Data(){
        cout << "析构函数" << num << endl;
    }
};
void test01(){

    //调用有参构造函数（隐式调用）
     Data ob3 = Data(100);
     cout<<"ob3.num = "<<ob3.num<<endl;

    //显式调用拷贝构造函数
    Data ob5 = Data(ob3);
    cout<<"ob5.num = "<<ob5.num<<endl;

    //隐式调用拷贝构造函数
    Data ob6(ob3);
    cout<<"ob6.num = "<<ob6.num<<endl;

    //隐式转换调用拷贝构造函数
    Data ob7 = ob3;
    cout<<"ob6.num = "<<ob6.num<<endl;
}

int main(int argc, char *argv[])
{
    cout << "-----------01----------" << endl;
    test01();
    cout << "-----------02----------" << endl;
    return 0;
}

记住一句话：旧对象初始化新对象才会调用拷贝构造函数

Data ob1(10);
Data ob2(ob1);//拷贝构造
Data ob3 = Data(ob1);//拷贝构造
Data ob4 = ob1;//拷贝构造函数

注意：下方就不会调用拷贝构造

Data ob1(10);
Data ob2;
ob2 = ob1;//不会调用拷贝构造 单纯对象 赋值操作

案例：

void test02(){
     Data ob1 = Data(100);
     Data ob2;
     ob2 = ob1;
     cout<<"ob1.num = "<<ob1.num<<endl;
     cout<<"ob2.num = "<<ob2.num<<endl;



}

int main(int argc, char *argv[])
{
    cout << "-----------01----------" << endl;
    test02();
    cout << "-----------02----------" << endl;
    return 0;
}

在这里插入图片描述

4、拷贝函数的注意事项

（1）不能调用拷贝构造函数区初始化匿名对象
（2） 对象作为函数的参数 如果实参与形参都是普通对象 那么就会调用拷贝构造
（3）函数返回局部对象，在qt中会被优化，从而调用不了拷贝构造

知识点9【构造函数的调用规则】

系统默认会对任何一个类提供三个函数成员函数：
默认构造函数（空） 默认析构函数（空） 默认拷贝构造函数（浅拷贝）
1、如果用户提供了有参构造，将会屏蔽系统的默认构造函数
2、如果用户提供了有参构造，不会屏蔽系统的默认拷贝构造函数
3、如果用户提供了拷贝构造函数，将会屏蔽系统的默认构造函数和默认拷贝构造函数

知识点10【深拷贝与浅拷贝】

1、浅拷贝
浅拷贝只复制某个对象的引用，而不复制对象本身，新旧对象还是共享同一块内存
2、深拷贝
深拷贝会创造一个一摸一样的对象，新对象和原对象不共享内存，修改新对象不会改变原对对象。

浅拷贝：

#include <iostream>
#include<string.h>

using namespace std;


class Person{
private:
    char *m_name;
    int num;
public:

    Person(int a, char *name){
        num = a;
        m_name = new char[strlen(name)+1];
        strcpy(m_name,name);
        cout << "有参构造" <<endl;
    }


    ~Person(){
        delete [] m_name;
        cout << "空间已被释放" << endl;
        cout << "析构函数" << endl;
    }

    void setNum(int a){
        num = a;
    }
    void setString(char* str){
         strcpy(m_name,str);
    }

    void showPerson(){
        cout << m_name << "  "<< num << endl;
    }


};
int main(int argc, char *argv[])
{
    Person person = Person(100,"lucy");
    Person bob1 = person;
    cout<<"------person输出值-------"<<endl;
    person.showPerson();
    person.setNum(1000);
    person.setString("lucy2");//修改person中m_num的值
    cout<<"------person输出值-------"<<endl;
    person.showPerson();
    cout<<"------bob1输出值-------"<<endl;
    bob1.showPerson();

    return 0;
}

运行结果：
在这里插入图片描述

使用person去初始化bob1调用拷贝构造函数，我们的目的是将person中的内容拷贝到bob1的空间中，但实际上，使用浅拷贝的方式只是改变了bob1的指向，让bob1指向person所指向的空间（person和bob1的字符串m_name指向堆区同一块空间），因此，当使用函数person.setString(“lucy2”)对字符串进行修改后，bob字符串的值也会被修改，;这会使得调用析构函数时，同一空间被释放两次，造成错误；
深拷贝：

#include <iostream>
#include<string.h>

using namespace std;


class Person{
private:
    char *m_name;
    int num;
public:

    Person(int a, char *name){
        num = a;
        m_name = new char[strlen(name)+1];
        strcpy(m_name,name);
        cout << "有参构造" <<endl;
    }
    Person(const Person &ob){
        num = ob.num;
        m_name = new char[strlen(ob.m_name)+1];
        strcpy(m_name,ob.m_name);
        cout << "有参构造" <<endl;
    }


    ~Person(){
        delete [] m_name;

        cout << "空间已被释放" << endl;
        cout << "析构函数" << endl;
    }

    void setNum(int a){
        num = a;
    }
    void setString(char* str){
         strcpy(m_name,str);
    }

    void showPerson(){
        cout << m_name << "  "<< num << endl;
    }


};


int main(int argc, char *argv[])
{
    Person person = Person(100,"lucy");
    //Person bob = Person(person);
    Person bob1 = person;
    cout<<"------person输出值-------"<<endl;
    person.showPerson();
    person.setNum(1000);
    person.setString("lucy2");
    //bob.showPerson();
    cout<<"------person输出值-------"<<endl;
    person.showPerson();
    cout<<"------bob1输出值-------"<<endl;
    bob1.showPerson();

    return 0;
}

运行结果：
在这里插入图片描述
从代码运行结果来看，我们可以通过重新构建拷贝构造函数的方式，完成深拷贝的工作，就算person对象对值进行修改，也不会影响bob的值。
注意：如果类中的成员指向了堆区空间，一定要记得在析构函数中释放空间。如果用户不实现拷贝构造，系统就会提供默认拷贝构造值，而默认拷贝构造只是单纯的赋值，如果赋值为指针的话，则两个对象会指向同一块堆区空间，容易造成浅拷贝的问题。用户记得要实现：无参构造（初始化数据）、有参构造（赋参数）、拷贝构造（深拷贝）、析构函数（释放空间）。

知识点11【初始化列表】

注意：初始化成员列表（参数列表）只在构造函数使用

#include <iostream>

using namespace std;

class Data{
public:
    int m_a;
    int m_b;
    int m_c;

    Data(int a,int b,int c):m_a(a),m_b(b),m_c(c){
        cout<<"有参构造函数"<<endl;
    }
    ~Data(){
         cout<<"析构函数"<<endl;
    }
    void showData(){
        cout << m_a << " " << m_b << " " << m_c << endl;
    }
};

int main(int argc, char *argv[])
{
    Data data = Data(10,100,1000);
    data.showData();
    return 0;
}

知识点12【类对象作为另一个类的成员】

#include <iostream>

using namespace std;



class A
{
    private:
    int m_a;
public:
    A()
    {
        cout<<"A无参构造函数"<<endl;
    }
    A(int a)
    {
        m_a = a;
        cout<<"A有参构造函数"<<endl;
    }
    ~A()
    {
        cout<<"A析构函数"<<endl;
    }
};
class B
{
    private:
    int m_b;
public:
    B()
    {
        cout<<"B无参构造函数"<<endl;
    }
B(int b)
{
    m_b = b;
    cout<<"B有参构造函数"<<endl;
}
~B()
{
    cout<<"B析构函数"<<endl;
}
};

class Data
{
private:
    A oba;//对象成员
    B obb;//对象成员
    int data;//基本类型成员
public:
    Data()
    {
        cout<<"Data无参构造"<<endl;
    }

        //初始化列表:对象名+() 显示调用 调用对象成员的构造函数
    Data(int a, int b, int c):oba(a),obb(b),data(c)
    {
        //data =c;
        cout<<"Data有参构造"<<endl;
    }
    ~Data()
    {
        cout<<"Data析构函数"<<endl;
    }

};
void test01()
{
    //先调用 对象成员的构造‐‐>自己的构造函数‐‐>析构自己‐‐‐>析构对象成员
    //Data ob1;

    //系统默认调用的是 对象成员的无参构造
    //必须在Data的构造函数中 使用初始化列表 使其对象成员 调用有参构造
    Data ob2 = Data(10,20,30);

}
int main(int argc, char *argv[])
{

    test01();
    return 0;
}

注意：类中的成员变量中如果有对象实例化的对象，则在对该类进行实例化时，应该先满足实例化的对象的构造函数条件。

米兰的小红黑
关注
  • 2
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++入门基础------类的介绍
小哥的博客
08-18 1997
类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量；创建对象的过程也叫类的实例化。与结构体一样，类只是一种复杂数据类型的声明，不占用内存空间。而对象是类这种数据类型的一个变量，或者说是通过类这种数据类型创建出来的一份实实在在的数据，所以占用内存空间。public ://成员变量 char * name;int age;//成员函数 void say() {cout
C++/CLI :类的属性
三余丨无梦生
03-25 1801
属性是C++/CLI的类成员，它类似于成员变量，但实际上不是。其主要区别在于，字段名引用了某个存储单元，而属性名则是调用某个函数。属性拥有访问属性的set()和get()函数。当我们使用属性名时，实际上在调用该函数的get()或set()函数。如果一个属性仅提供了get()函数，则它是只读属性；如果一个属性仅提供set()函数，则它是只写属性。 类可以有2种不同的属性：标量属性和索引属性。标量属...
C++学习小记之类和属性
weixin_44336538的博客
03-19 173
关于类的一些术语 类中的属性和行为 统一称为成员 属性 成员属性，成员变量 行为 成员函数 成员方法 设置一个学生类 // C++学习.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // #include <iostream> using namespace std; #include<string> //设计学生类 class Student { //访问权限 //公共权限 public: //属性 //半
c/c++ 获取文件的属性
百鸣的专栏
05-30 9351
【Kenmark】: http://topic.csdn.net/t/20021127/11/1209086.html http://topic.csdn.net/t/20020613/19/801649.html http://topic.csdn.net/t/20020918/09/1032607.html 【nevergone】: GetFileAttributes 【K
通过命令提示符查看c++中类的构造
wu___hao的博客
08-24 388
第一步：在电脑中搜索vs，会出现下面内容（交叉工具命令提示符）： 输入当前路径： 输入dir，找到我们的（继承.cpp）： 输入cl -d1reportSingleClassLayout(clasname) (XX.cpp) /EHsc,我们在本例中的类是（derve）,类名是（继承.cpp） cl -d1reportSingleClassLayoutderve 继承.cpp /EHsc，最终结果如下： ...
C++类中的继承实例详解
08-30
C++类中的继承实例详解 C++ 类中的继承是面向对象编程（Object-Oriented Programming，OOP）的一种重要机制，允许开发者创建出具有继承关系的类。继承机制可以实现代码的重用和简化代码的编写。 在 C++ 中，继承是...
C++中的类模板详解及示例
01-20
C++中的函数模板 对于类的声明来说，也有同样的问题。有时，有两个或多个类，其功能是相同的，仅仅是数据类型不同，如下面语句声明了一个类： 代码如下:class Compare_int{ public: Compare(int a,int b) { x=a...
C++空类详解
12-31
空类默认产生的成员：class Empty {};Empty(); // 默认构造函数Empty( const Empty& ); // 默认拷贝构造函数~Empty(); // 默认析构函数Empty& operator=( const Empty& ); // 默认赋值运算符Empty* operator&(); /...
C++ 中消息队列函数实例详解
08-30
C++ 中消息队列函数实例详解 C++ 中消息队列函数实例详解是指在 C++ 语言中使用消息队列函数来实现进程间通信的方法。消息队列是一种 IPC（Inter-Process Communication）机制，允许不同的进程之间进行数据交换和...
C++ 处理中文符号实例详解
01-01
C++ 处理中文符号 英文符号替换为英文逗号 processPunctuation(string& tag) { std::set<char> punctuation_set; punctuation_set.insert(' '); punctuation_set.insert('\t'); punctuation_set.insert(';'); ...
获取类中属性的过程
见证我的poj成长之路
12-10 576
Python的类中，属性分为实例属性和类属性。通过实例可以访问实例和类属性，通过类名只能访问类属性。下面分辨就这两种方式来给出属性的访问流程。 测试代码： class C(object): a = 'abc' def __getattribute__(self, item): print("__getattribute__ called.") ...
C++类成员属性的一种简洁实现
BlueDog专栏
12-14 8378
                  C++类成员属性的一种简洁实现    一般来说对于标准C++而言是不存在成员属性这个概念的，以前大家都是用GetXXX/SetXXX来访问或取得数据，好象也没有感觉到任何不便。但是当我们用过C#之类的语言之后，我们总觉得C++这个方式太老土了。于是我们想去实现“属性”这个C++语言缺乏的要素。事实上网络上有很多人已经做了这部分工作，实现的方法有很多种，一种是用模
C++ 获取类型信息
weixin_45743799的博客
03-14 6400
typeid 运算符用来获取一个表达式的类型信息。类型信息对于编程语言非常重要，它描述了数据的各种属性： 对于基本类型（int、float 等C++内置类型）的数据，类型信息所包含的内容比较简单，主要是指数据的类型。 对于类类型的数据（也就是对象），类型信息是指对象所属的类、所包含的成员、所在的继承关系等。 类型信息是创建数据的模板，数据占用多大内存、能进行什么样的操作、该如何操作等，这...
获取class中属性名称及属性类型
shang1219178163的专栏
02-12 1918
-(void)getTheClassPropertyNameAndAttributes:(NSString *)className withDic:(NSMutableDictionary *)returnDic { const char *cClassName = [className UTF8String];（1）   id theClass = objc_getClass(cClassN
C++如何获取文件属性
记事本
02-17 4960
C++如何获取文件属性，stat系统调用系列包括了fstat、stat和lstat，它们都是用来返回“相关文件状态信息”的，三者的不同之处在于设定源文件的方式不同。 stat系统调用系列包括了fstat、stat和lstat，它们都是用来返回“相关文件状态信息”的，三者的不同之处在于设定源文件的方式不同。 1 首先隆重介绍的是一个非常重要的”VIP”人物，他是fstat, stat和ls
获取一个类所有属性
彻底拆分，一切可控！
02-24 3985
获取类所有属性
c++调用类成员和属性的几种方法
Dch19990825的博客
01-31 6110
c++类关于类静态成员和方法和类的普通成员和方法的关系以及区别 下面把静态属性(方法)称为类的属性(方法) ，普通属性(方法)称为对象的属性(方法) 调用类成员和属性的几种方法 /* 调用类成员和属性的几种方法: 类名::属性或方法名 对象.属性或对象名 */ #include&amp;lt;cstdio&amp;gt; #include&amp;lt;iostream&amp;gt; using namesp...
c++利用属性名设置和获取属性值
feijinxinsi的博客
10-21 1559
/*  * @Filename:CMetaDataManager.h  * @Date:2016-10-21  * @Author:yuanzuochao  * @Description:  *    * @History:  * Date                     Author                  Records  * 2016-10-21     ...
6_string类讲义1
最新发布
08-03
本讲义主要围绕C++中的string类进行深入讲解，针对的是面向对象程序设计中的一个重要内容。string类在C++中是一个模板类，其基础类型为char，通过typedef定义为string。在编程中使用string类时，必须包含对应的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值