C++——02类的基本特性

已于 2024-04-07 22:39:05 修改
阅读量375 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2021-08-05 19:10:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/minddjx/article/details/119410900
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言

提示：这里可以添加本文要记录的大概内容：
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

提示：以下是本篇文章正文内容，下面案例可供参考

一、封装的过程

1.定义

1.数据访问权限

类内：类的设计者编写代买的地方
类外：类的使用者编写代码的地方
访问权限关键字只限制类外，不限制类内。
(1)pubilc:允许类外访问
(2)privent
(3)protect

2.类对象内存空间

类中数据类型所占空间按c语言结构体对齐规则计算，函数名不占空间。如果类种不存在数据类型则，只有一个字节空间为了让使用则能够调用，预留出一字节的空间。

3.构造函数

调用时无需传参的构造函数称为默认构造函数
任意对象在创造时都会触发构造函数，构造函数没有返回值，名字与类名相同。目的是为了初始化类内成员。
在使用时如果调用默认构造，则可以不用写括号。
如果要传参则写括号写默认形参。
构造函数执行的过程：
（1）传参
（2）按照数据成员声明的数据类型为数据成员开辟内存空间
（3）执行构造函数函数体
初始化列表
初始化的顺序，与数据成员声明的数据相同，放在构造函数定义的地方。

分类：
按照参数分类，可以分为有参构造函数和无参构造函数（默认）
按照类型分类，可以分为普通构造函数和拷贝构造函数

#include<iostream>
using  namespace std;
#include<string>
class Persion
{
private:
    /* data */
public:
    Persion() {/*默认构造函数*/
        cout << "this no args structure fun" << endl;
    } 
    Persion(int age) { /*复制构造函数*/
        m_age = age;
        cout << "this args structure fun" << endl;
    }
    Persion(const Persion &p) { /*必须穿传引用*/
        m_age = p.m_age;
        cout << "this copy structure fun" << endl;
    }
    ~Persion();
    int m_age;
};

// Persion::Persion(/* args */)
// {
// }

Persion::~Persion()
{
}
/* 调用 */
void test()
{
    /*1.括号法*/
    // Persion p1;
    // Persion p2(18);
    // Persion p3(p2);
    // //注意事项：
    // //不要在括号去调用默认构造函数去创建对象。编译器会认为是一个函数声明：
    // Persion p4(); //错误的示范
    // void test1(); //函数声明

    /*2.显示法*/
    // Persion p1;
    // Persion p2 = Persion(10); //有参构造
    // Persion p3 = Persion(p2); //拷贝构造
    // Persion p3(p2);
    //注意事项1
    // Persion (10);//匿名对象 特点：当前执行后编译器会立即回收匿名对象

    //注意事项2
    // 不要利用拷贝构造函数创建匿名对象，Person (p3) = Person p3;

    /*3.隐式转换法*/
    Persion p4 = 4;    //有参构造
    Persion p5 = p4;   //拷贝构造

}
int main()
{
	test();
    cout << "this main fun" << endl;
}

4.复制构造函数

复制构造函数一定是本类对象的常引用
使用范围/调用时机:
(1)使用已有的对象创建另一个对象
(2)函数值传递形参是类对象会触发复制构造函数
(3)类对象作为函数的返回值，会得到一个匿名函数。

#include<iostream>
using  namespace std;
#include<string>
class Persion
{
private:
    /* data */
public:
    Persion() {/*默认构造函数*/
        cout << "this no args structure fun" << endl;
    } 
    Persion(int age) { /*复制构造函数*/
        m_age = age;
        cout << "this args structure fun" << endl;
    }
    Persion(const Persion &p) { /*必须穿传引用*/
        m_age = p.m_age;
        cout << "this copy structure fun" << endl;
    }
    ~Persion() {
        cout << "this  destructure fun" << endl;
    }
    int m_age;
};

void do_work(Persion p) {
    cout << "this is a test" << endl;
}
/*1.用一个已有的对象进行创建*/
void test01(void) {
    Persion p1(10);
    Persion p2(p1);
}
/*2.做函数参数*/
void test02(void) {
    Persion p1;
    do_work(p1);
    
} 
Persion do_work2(void) {
    cout << "this is a test" << endl;
    Persion p1;
    cout << (int*)&p1 <<endl;
    return p1;
}
/*3.做函数返回值*/
void test03(void) {
    
    // Persion p = test02();
    Persion p2 = do_work2();
    cout << (int*)&p2 <<endl;
}
int main()
{
	// test();
    /*1.用一个已有的对象进行创建*/
    // test01();
    // test02();.
    test03();


    // test04();
   
    cout << "this main fun" << endl;
}

默认情况下，c++会给类添加至少三个函数
1.默认构造函数，函数体为空
2.默认析构函数，函数体为空
3.默认拷贝函数，对属性进行拷贝

构造函数调用规则如下：
1.如果用户定义了有参构造函数，c++不在提供默认构造函数，但是会提供拷贝构造函数
2.如果用户定义了拷贝构造函数，不会再提供其他构造函数

4.1深拷贝与浅拷贝

浅拷贝，带来的问题是堆区内存重复释放
如果属性有再堆区开辟的，一定要在自己提供的拷贝构造函数，防止浅拷贝带来的问题

#include<iostream>
using  namespace std;
#include<string>
class Persion
{
private:
    /* data */
public:
    Persion() {/*默认构造函数*/
        cout << "this no args structure fun" << endl;
    } 
    Persion(int age,int height) { /*带参构造函数*/
        m_age = age;
        m_height = new int(height);
        cout << "this args structure fun" << endl;
    }
    Persion(const Persion &p) { /*拷贝构造函数*//*必须穿传引用*/
        m_age = p.m_age;
         m_height = new int(*p.m_height);
        cout << "this copy structure fun" << endl;
    }
    ~Persion() {
        if(!m_height) {
            delete m_height;
        }
        cout << "this  destructure fun" << endl;
    }
    int m_age;
    int *m_height;
};

void do_work(Persion p) {
    cout << "this is a test" << endl;
}
/*1.用一个已有的对象进行创建*/
void test01(void) {
    Persion p1(10,160);
    Persion p2(p1);
}
/*2.做函数参数*/
void test02(void) {
    Persion p1;
    do_work(p1);
    
} 

int main()
{
	test01();
   
    cout << "this main fun" << endl;
}

4.2初始化列表

class Test
{
private:
    /* data */
public:
    // Test(/* args */);
    ~Test();
    Test(int a, int b, int c):m_a(a),m_b(b),m_c(c){

    }
    int m_a;
    int m_b;
    int m_c;


};

Test::~Test()
{
}


int main()
{
	Test a(1 , 2, 3);

    cout << "a.m_a = "<<a.m_a<<endl;
    cout << "a.m_b = "<<a.m_b<<endl;
    cout << "a.m_c = "<<a.m_c<<endl;
    cout << "this main fun" << endl;
}

当其他类对象作为本类函数成员的时候，构造时候先构造类对象，再构造自身，构造的顺序和析构的顺序相反

4.3静态成员

  • 静态成员变量的特点
    所有的对象共享一份数据
    再编译阶段分配内存
    类内申明，类外初始化
    访问方式：
    1.通过对象进行访问
    2.通过类名进行访问
    静态成员变量有访问权限


/*类的静态成员*/
class StaticTest
{
private:
    /* data */
public:
    StaticTest(/* args */);
    ~StaticTest();
    static int m_a;
};

int StaticTest::m_a = 10;
StaticTest::StaticTest(/* args */)
{
}

StaticTest::~StaticTest()
{
}

void test_static_num(void){
    cout <<StaticTest::m_a <<endl;
}

int main()
{
    StaticTest T;
    cout <<StaticTest::m_a <<endl;
    T.m_a = 20;
    cout <<T.m_a <<endl;
	test_static_num();
}
  • 静态成员函数
    所有的对象共享一个函数
    静态成员函数只能访问静态成员变量

5.析构函数

析构函数不允许带参数。
析构函 数执行流程：
1.执行析构函数函数体
2.按照数据成员声明的数据类型的逆顺序为数据成员开辟内存空间

6.C++对象模型和this指针

c++成员变量和成员函数是分开存储，
如果是一个类的类型是成员变量是空，内存大小是1字节，是编译器为了和其他类对象进行区分，创建的。

在类成员函数系统会默认传一个THIS指针
用途是：
1.解决名称冲突
2.返回对象本身用*this

class ThisPiont
{
private:
    /* data */
public:
    ThisPiont(/* args */);
    ThisPiont(int num){
        /*1.用于区别*/
        this->num = num;
    }
    ~ThisPiont();
    ThisPiont& add_fun(ThisPiont p) {
        this->num += p.num;
        return *this;/*指向函数本身*/
    }
    int num;
};

ThisPiont::ThisPiont(/* args */)
{
}

ThisPiont::~ThisPiont()
{
}


int main()
{
    ThisPiont p1(10);
    ThisPiont p2(10);
    // test.add_fun(test);
    /*链式编程思想，类似与cout*/
    p2.add_fun(p1).add_fun(p1).add_fun(p1);
    cout << "p1 test.num" <<p1.num <<endl;
    cout << "p2 test.num" <<p2.num <<endl;
}

6.1 this如果是空

class ThisPiont
{
private:
    /* data */
public:
    ThisPiont(/* args */);
    ThisPiont(int num){
        /*1.用于区别*/
        this->num = num;
    }
    ~ThisPiont();
    ThisPiont& add_fun(ThisPiont p) {
        this->num += p.num;
        return *this;/*指向函数本身*/
    }
    void fun1(void) {
        cout << "this fun1 " << endl;
    }
    void fun2(void) {
        if (this == NULL) {
            return;
        }
        cout << "this fun2" << num <<endl;
    }
    int num;
};

ThisPiont::ThisPiont(/* args */)
{
}

ThisPiont::~ThisPiont()
{
}


int main()
{
    ThisPiont p1(10);
    ThisPiont p2(10);
    ThisPiont *test = NULL;
    test->fun1();
    test->fun2();
}

6.2 this 指针本质

是一个指针常量，指针指向不可以修改
类似与于 Person *const this;

6.3 常函数

class ThisPiont
{
private:
    /* data */
public:
    ThisPiont(/* args */);
    ThisPiont(int num){
        /*1.用于区别*/
        this->num = num;
    }
    ~ThisPiont();
    ThisPiont& add_fun(ThisPiont p) {
        this->num += p.num;
        return *this;/*指向函数本身*/
    }
    /*常函数：在函数后面加const ,修饰的是this指针的指向，让指针指向的值也不可以修改*/
    void showPont(void) const
    {
        // this->num = 100;/*error*/
        this->numtest = 100;
    }

    void fun() {

    }
    int num;
    mutable int numtest;/*在常函数中，加入mutable 可以被修改*/
};

ThisPiont::ThisPiont(/* args */)
{
}

ThisPiont::~ThisPiont()
{
}

void test03(void) {
    const ThisPiont test;
    test.showPont();/*常对象只能调用常函数*/
    //test.fun();/*error*/
}

int main()
{
   
   test03();
}

6.3友元函数

共有以下几类：
1.全局函数：将函数的声明在类内，并且在前面加一个friend，这样全局函数就可以访问，类内的私有成员

friend void test(void);

2.类做友元：将类的声明在类内，并且在前面加一个friend，另一个类就可以访问，类内的私有成员

friend class TEST;

3.成员函数：将类的成员函数的声明在类内，并且在前面加一个friend，这样全局函数就可以访问，类内的私有成员
TEST 类下面的test函数可以访问声明了类的私有成员

friend TEST::void test(void);

7.类的组合

如果某个类当中的数据成员要其带参构造构造时，使用初始化列表向其传参。

8.系统提供的类函数

	1.默认构造函数
	2.默认复制构造函数
	3.默认析构函数
	4.默认复制运算符重载函数
	5.非常对象取地址运算符重载
	6.常对象取地址运算符重载
	7.移动复制运算符
	8.移动复制构造函数
mindDJX
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
这些课堂上不教的 C++ 的基本特性你都知道吗？
C语言与CPP编程的博客
10-18 839
来源：https://zhuanlan.zhihu.com/p/149839787C++ 作为一个历史久远，功能丰(yong)富(zhong)而且标准与时俱进的语言，理应什么都能做，什么...
详解C++基础——类继承
08-26
在C++编程中，类继承是面向对象编程（OOP）的一个核心概念，它允许一个类（称为派生类）从另一个类（称为基类）继承特性。这使得程序员能够复用代码，同时还能根据需求扩展或修改原有功能。本文将深入探讨C++中的类...
C++基础知识（1）基本特性
qq_45617648的博客
04-09 145
临时对象都是右值，而右值引用主要负责处理临时对象，程序执行时生成的中间对象就是临时对象，临时对象产生后很快就会被销毁。就是匿名函数，普通的函数在使用前需要将这个函数定义，因此提供了lambda表达式，省去了定义函数的过程。如果一个对象可以使用运算符 “()” ，()里面可以放参数，那么这个对象就是可调用对象。具有operator()的函数的类对象，此时类对象可以当做函数使用，称为仿函数。指针都是存储在栈上或者堆上的，不管在栈上还是堆上，都一定有一个地址。：以a的值为地址的地方所存储的值。
c++基本特性
weixin_30538029的博客
07-08 300
C++支持多种编程范式 －－面向对象编程、泛型编程和过程化编程。常用于系统开发，引擎开发等应用领域。 与C的关系 C语言是C++的基础，C++和C语言在很多方面是兼容的。 C语言是一个结构化语言，它的重点在于算法与数据结构。C程序的设计首要考虑的是如何通过一个过程，对输入（或环境 条件）进行运算处理得到输出（或实现过程（事物）控制）。C++，首要考虑的是如何...
C++：相对于C的C++基本特性
kafmws的博客
01-14 606
从C到C++ 本文介绍从C语言过渡到C++的一些基本语法或特性 C++与C是两种语言， C++没有完全兼容C，所有C代码在 cpp 文件中表示的是另外一种含义，只是表现得符合C的行为 在 cpp 中只有显式使用 extern C { } 说明时，compiler 才把代码作为C处理 引用 int a = 3; int & b = a;//创建a的引用 上面两行代码创建了变量 a 的引用...
2.C++基本特性
qq_55998987的博客
02-22 74
C++区别于C语言的一些特性
C++——HIS排班系统for Neuedu
04-20
在本项目"C++——HIS排班系统for Neuedu"中，我们主要探讨的是一个基于C++编程语言，利用Qt框架开发的医疗信息系统（HIS）中的排班管理模块。东软云HIS医院管理系统是一款高效、全面的医疗信息化解决方案，而基础...
C++——图书管理系统课程设计
09-26
首先，我们需要了解C++的基本语法和特性。C++是一种静态类型的、编译式的、通用的、大小写敏感的、不仅支持过程化编程，也支持面向对象编程的程序设计语言。它的核心特性包括类（class）、封装、继承、多态性等，...
c++类和对象基本概念（csdn）————程序.pdf
12-01
C++ 类和对象基本概念 本文将介绍 C++ 中的类和对象基本概念，包括类的定义、类的特点、对象的概念、类的实现、权限限定词的作用、创建对象的方法等。 类的概念： 在 C++ 中，类是一系列事物的抽象，万事万物都...
C++的特性
GoodLinGL的博客
04-08 2073
C是面向过程的语言，是一个结构化的语言，考虑如何通过一个过程对输入进行处理得到输出；C++是面向对象的语言，主要特征是“封装、继承和多态”。封装隐藏了实现细节，使得代码模块化；派生类可以继承父类的数据和方法，扩展了已经存在的模块，实现了代码重用；多态则是“一个接口，多种实现”，通过派生类重写父类的虚函数，实现了接口的重用。 C和C++动态管理内存的方法不一样，C是使用malloc/free，而C++除此之外还有new/delete关键字。 C++支持函数重载，C不支持函数重载 C++中有引用..
C++三大特性
weixin_55271823的博客
11-06 4620
特性
C++类的基本特性
王学门徒
09-17 1406
目录 1.C++类中默认的六大函数 2.关于C++类中this 以及拷贝构造函数的理解 3.C++类中的赋值函数 4.C++中调用拷贝构造函数的情况 1.C++类中默认的六大函数 #include <iostream> using namespace std; // C++的类中都有默认的六大函数 class Test{ public: Test(int d...
学习c++ 必知三大特性
baidu_16370559的博客
07-02 1490
且重载时可以给重载函数定义新的属性，例如public，其只标志着该重载函数在该子类中的访问属性为public，和父类的private属性没有任何关系！不过按照C++的设计思想来说呢，基类中的非virtual类型的成员函数，是不需要在子类中进行修改的，所以如果在子类中出现了这种隐藏的情况，说明应该将基类中的该函数改成virtual类型的，然后就是重写了。当程序在编译期间，编译器会为构造函数中增加为vptr赋值的代码(这是编译器的行为)，当程序在运行时，遇到创建对象的代码，执行对象的。A *p = &b;
C++面向对象的三个基本特征
qq_39542885的博客
08-11 1209
面向对象的三个基本特征 (1)封装：将客观事物抽象成类，每个类对自身的数据和方法实行protection(private, protected,public) (2) 继承：广义的继承有三种实现形式：实现继承（指使用基类的属性和方法而无需额外编码的能力）、可视继承（子窗体使用父窗体的外观和实现代码）、接口继承（仅使用属性和方法，实现滞后到子类实现）。前两种（类继承）和后一种（对象组...
C++四大特性——多态 的总结
热门推荐
jhcconan614的博客
03-11 1万+
我们都知道，C语言和C++的区别就是，C语言是面对过程的程序设计，而C++是面对对象的程序设计。面对对象的程序设计有4大特性：分别是，抽象、封装、继承、多态。今天我们就来总结一下多态的内容。多态：分为静态多态和动态多态：静态多态：编译器在编译期间完成的，编译器会根据实参类型来推断该调用哪个函数，如果有对应的函数，就调用，没有则在编译时报错。比如一个简单的加法函数：include<iostream>
C++基本特性
lixiao_bupt的专栏
10-28 728
大多数开发人员通常都有这个观点，即汇编语言和 C 语言适合用来编写对性能要求非常高的程序。而 C++ 语言的主要应用范围是编写复杂度非常高的程序，但是对性能要求不是那么严格的程序。但是事实往往并非如此，很多时候，一个程序的速度在框架设计完成时大致已经确定了，而并非是因为采用了C++语言才使其速度没有达到预期的目标。因此当一个程序的性能需要提高时，首先需要做的是用性能检测工具对其运行的时间分布进行一
C++类的一些基本特性
最新发布
ly1611240037的博客
04-17 165
类有三个访问限定符，public（公有），protected（保护），private（私有）说明：1.public修饰的成员在类外可以被直接访问2.protected与private修饰的成员在类外不能被访问3.访问限定符的作用域是从访问限定符出现的位置为始，到下一个访问符出现为止4.若后面没有其他限定符，作用域到}结束，即类的结束5.class默认访问权限为private，struct默认访问权限为public（因为要兼容C语言）6.访问限定符只在编译时有用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值