C++基础语法4（ 类型转换、封装、构造、析构函数、this指针）

已于 2023-10-25 17:16:04 修改
阅读量39 收藏
点赞数
分类专栏： C++基础 文章标签： 1024程序员节
于 2023-10-24 18:19:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43287578/article/details/134017565
版权

目录

类型转换：

1.static_cast(expr):

2.reinterpret_cast(expr);

3.dynamic_cast(expr);

4..const_cast(expr);

封装：

构造函数：

析构函数：

this指针：

初始化列表：

类型转换：

C语言的隐式转换和显示转换举例如下：

#include <stdio.h>

int main()
{
    int num = 5;
    double b = (double)num; //显示转换 强制类型转换
}

C++的类型转换运算符（共四类）：

能区分四个类型的作用以及使用方法等

static_cast<T>(expr);
const_cast<T>(expr);
dynamic_cast<T>(expr);
reinterpret_cast<T>(expr);

1.static_cast(expr):

static_cast:相关类型，子类转父类，void*转换成任意类型指针

void* 为万能指针，可以接收任意类型的指针值

#include <iostream>

using namespace std;

int main()
{
    int num = 5;
    
    double b = static_cast<double>(num);
    char ch = static_cast<char>(num);
    
    cout << b << endl;
    cout << ch << endl;
    
    int *p_num = &num;
    char *p_ch = &ch;
    //指针必须是相同类型指针赋值，不同类型指针赋值会导致指针的步长发生变化
    //步长发生变化，会影响到数据的组成
    p_ch = p_num; //无法赋值
    
    int a = 0X12345678;
    int *p =&a;
    char *ptr = p;
    //此时ptr的值小端时为78，大端为12
    
    void *p = p_num;
    void *p2 = p_ch;
    
    int *p_num2 = static_cast<int *>(p);
    //p转换成int形指针
    
    *p_ch = static_cast<int *>(p); //不允许任意类型指针之间转换
    return 0;
}

2.reinterpret_cast(expr);

相当于C语言的强制类型转换（可以转换成任意类型（包括指针））

缺点：不安全,限定适用范围：指针和引用

不建议使用

#include <iostream>

using namespace std;

int main()
{
    int num = 0x12345678;

    
    int *p_num = &num;
    char *p_ch = &ch;
    void *p = p_num;
    void *p2 = p_ch;

    p_ch = reinterpret_cast<char*>(p_num);
    char ch2 = reinterpret_Cast<char>(num);//不支持
}

3.dynamic_cast(expr);

多态 RTTI

4..const_cast(expr);

去除指针和引用的const属性，只能在指针和引用前加(使用较少)

#include <iostream>

using namespace std;

int main()
{
    int num = 0x12345678;

    const int count = 5; //const:常量
    const int *p_count = &count;
    const int &l_rcount = count;
    
    int *p_count1 = const_cast<int*>(p_count);
    //去除了p_count的const属性
    (*p_count1)++;
    cout << *p_count1 << endl; //输出6
    cout << count << endl; //输出5
    
    int &l_rcount = l_rcount; //报错，左右两边必须为const
    int &l_rcount = const_cast<int&>(l_rcount); 
    
    string s("helllo world!");
    char *ptr = const_cast(char *)(s.c_str()); //无法转化常量
    
    return 0;
}

封装：

可以达到对外提供接口，屏蔽数据，对内开放数据。

提高了代码的维护性，继承提高代码的复用性；封装+继承=扩展性

维护性：当代码出现问题时，能很快定位到出现问题的位置；越独立的代码越容易维护

C语言中的封装：当单一变量无法完成描述需求的时候，结构体类型解决了这一问题

问题：即知其接口，又可以直接访问其内部数据。

C++的封装：class封装的本质，在于将数据和行为绑定在一起然后通过对象来完成操作。

权限修饰符：public，private，protected:

class 类名称
{
    public:
        公有成员（外部接口）
    private：
    protected:
        
       
}

编程实例：

1.栈的实现：

C语言：

#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 100

enum Ret
{
    IS_FULL = -199 ,//随意给，不要重复
    IS_NOT_FULL,
    IS_EMPTY,
    IS_NOT_EMPTY,
    PUSH_SUCCESS,
    PUSH_FAILED,
    POP_SUCCESS,
    POP_FAILED
};

int is_full(int top)
{
    if(top == MAX_SIZE-1)
    {
        return IS_FULL;
    }
    return IS_NOT_FULL;
}

int is_empty(int top)
{
    if(top == -1)
    {
        return IS_EMPTY;
    }
    return IS_NOT_EMPTY;
}

void init_stack(int *top)
{
    *top = -1;
}

int push(int * stack, int * top, int* num) //压栈函数
{
    if(is_full(*top) === IS_FULL);
    {
        return POUSH_FAILED;
    }
    (*top)++;
    stack[*top] == num;
    
    return PUSH_SUCCESS;
}

int pop(int * stack, int *top) //出栈函数
{
    if(is_empty(*top) === IS_EMPTY);
    {
        return POP_FAILED;
    }
    return stack[stack(*top)--];
}


int main()
{
    int stack[MAX_SIZE] = {0}; //初始化
    int top;
    
    init_stack(&top);
    
    for(int i = 0; i < 5; i++) //压栈
    {
        if(push(stack,&top,i) == IS_FULL)
        {
            printf("stack is full!\n");
            exit(1)
        }
    }
    
    int temp;
    for(int i = 0; i < 5; i++) //压栈
    {
        if((temp ==pop(stack,&top) == IS_EMPTY)
        {
            printf("stack is empty!\n");
        }
        printf("pop:%d\n",temp);
    }
    return 0;
}

C++

stack.h

#pragma once

class Stack //类名
{
    public: //类的方法，类的成员的方法
        void initStack(int len);
        int push(int num);
        int pop();
        bool isEmpty();
        bool isFull();
        int getTop();
        void freeStack();
    private: //属性，类的成员，私有变量无法改变，安全性高
        int top;
        int *stack;
        int maxLen;
};

stack.cpp

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

void Stack::initStack(int len)
{
    stack = new int[len];
    top = -1;
    maxLen = len;
}

bool Stack::isFull()
{
    if(top == maxLen-1)
    {
        return true;
    }

    return false;
}

bool Stack::isEmpty()
{
    if(top == -1)
    {
        return true;
    }

    return false;
}

int Stack::push(int num)
{
    if(isFull() == true)
    {
        return false;
    }

    stack[++top] = num;

    return true;
}

int Stack::pop()
{
    if(isEmpty() == true)
    {
        return false;
    }

    return stack[top--];
}

int Stack::getTop()
{
    return stack[top];
}

void Stack::freeStack()
{
    delete [] stack;
    stack = nullptr;
}

main.cpp:

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

using namespace std;

int main()
{
    Stack s;
    s.initStack(100);

    for(int i = 0; i< 5; i++)
    {
        if(s.push(i) == false)
        {
            cout <<"stack is full!" << endl;
        }
    }

    for(int i = 0; i < 5; i++)
    {
        cout << s.pop() << endl;
    }
    
    s.freeStack();
    return 0;
}

构造函数：

空类内自带的构造函数：

Empty(const Emply&); //默认拷贝构造函数
~Empty();            //默认析构函数
Empty&operator=(const Empty&) //默认赋值运算符
Empty *operator();   //取址运算符
const Empty* operator&() const; //取址运算符 const

人为操作的时候会忘记初始化和释放内存，C++使用构造函数和析构函数

构造函数：初始化

在编写时，先写构造，再在最后写析构函数，然后在中间添加自定义函数

构造函数：

特点：

1.自动调用（实例对象（定义对象）时，自动调用构造函数）

2.构造函数的函数名与类名一致

3.构造函数没有返回值

4.构造函数可以重载

5.当类里无任何构造函数时，系统会默认生成一个无参的构造函数；有任何一个构造函数都不会默认生成。

补充：C++ delete default

6.构造函数的种类

无参构造函数（系统默认生成的（空的），自定义实现的）；

有参构造函数（类型转换构造函数，拷贝构造函数（系统默认生成的，自定义实现的），移动拷贝构造函数）

类型转换构造函数(构造函数只有一个参数！）

explicit:防止编译器产生隐式转换，只能通过构造函数的方式来调用，类型转换构造函数必须加

拷贝构造函数 形参是该类型的对象引用，若类无自定义拷贝构造函数，系统会默认生成拷贝构造函数。

拷贝构造函数什么时候使用？

用已有的对象初始化对象会调用；当函数的形参是对对象的时候；当函数的返回值是类对象，函数执行返回的时候会调用拷贝构造函数。

深拷贝和浅拷贝（默认生成的拷贝为浅拷贝），类内有指针成员才会出现，浅拷贝：多个成员指向同一块空间，深拷贝：多个成员指向不同的空间

移动拷贝构造函数： 解决临时对象拷贝的开销问题，提高运行效率

对象移动：将该对象移动到目标对象的空间（把归属权交给新的对象，不发生拷贝）,解决对象拷贝赋值开销的问题

右值引用真正目的是把拷贝对象变成移动对象，省去拷贝构造时间，提高运行效率

如何不生成系统默认生成的无参构造？

自己写构造函数，

Student() = delete;//让系统不生成默认构造

Student() = default; //使用系统默认生成的无参构造。

运算符重载：

Test t8 = t1; //初始化，调用拷贝构造函数
Test t9;
t9 = t1; //隐式调用，赋值： = 运算符 ，等号运算符为浅拷贝
//运用重载运算符解决
Test & operator = (const Test &other)
{
    cout << "operator =" << endl;
    int len = strlen(other.m_ptr);
    this -> m_ptr = new char[len+1];
    strcpy(m_ptr, other.m_ptr);
    
    return *this;
}

//移动拷贝运算符重载
Test & operator = (const Test &other)noexcept //移动拷贝函数需要加
{
    cout << " move copy operator =" << endl;
    this->m_ptr = other,m_ptr;
    other.m_ptr = nullptr;
}

bool operator > (const Test &t)
{
    if(strcmp(t.m_ptr,this->m_ptr) > 0)
    {
        return true;
    }
    return false;
}

t2.operator = t1;//深拷贝

.h文件（添加在C++栈的响应文件中）

#pragma once

class Stack
{
    public:
        Stack(int len = 100)； //在类内指定了默认参数 .定义中就不需要指定
        //使用默认参数就无法使用重载
        
        Stack() = delete; //告诉编译器不生成默认无参构造函数
        Stack() = default; //使用系统自动生成的无参构造函数，不用自己构造的函数
        //系统生成的无参构造函数，什么工作都不做，空函数。
        //需要无参函数带有功能则要自己实现
};

 .cpp文件（添加在C++栈的响应文件中）

Stack::Stack()
{
    stack = new int[10];
    maxLen = len;
    top = -1;
}


Stack::Stack(int len)
{
    stack = new int[len];
    maxLen = len;
    top = -1;
}

各类构造函数：以下各类构造函数都建议写入 

#include<iostream>

using namespace std;

class Test
{
public:
    int m_num;
    int m_count;
    string m_s;
    char* m_ptr;
    //无参构造函数
    Test() : m_num(0)
    {
        cout << "Text" << endl;
    }
    //有参构造函数
    Test(int num, int count) : m_num(num), m_count(count)
    {
        cout << "Text(int,int)" << endl;
    }
    //析构函数
    ~Test()
    {
        if (this->m_ptr != nullptr)
        {
            delete[] m_ptr;
            cout << "~Test" << endl;
        }
    }
    //自定义拷贝构造函数（深拷贝，不在同一个地址）
    Test(Test& other)
    {
        cout << "copy Test" << endl;
        int len = strlen(other.m_ptr);
        this->m_ptr = new char[len + 1];
        strcpy(m_ptr, other.m_ptr);   //无置空操作形参加CONST           
    }

    //拷贝运算符重载（浅拷贝，两个指向同一个地址）
    Test& operator = (const Test& other) 
    {
        cout << " move copy operator =" << endl;
        this->m_ptr = other.m_ptr;
        this->m_count = other.m_count;
        this->m_num = other.m_num;
        this->m_s = other.m_s;
    }

    //运用重载运算符解决
    Test& operator = (const Test& other)
    {
        cout << "operator =" << endl;
        int len = strlen(other.m_ptr);
        this->m_ptr = new char[len + 1];
        strcpy(m_ptr, other.m_ptr);
        return *this;
    }


    //移动拷贝构造函数
    Test(Test&& other)noexcept //移动拷贝函数需要加，形参右值引用
    {
        cout << "move copy test" << endl;
        this->m_ptr = other.m_ptr;//对象移动，内存使用权交互
        other.m_ptr = nullptr;
        
    }

    Test getTest()
    {
        Test t(1,2); //临时对象，就是右值
        return t;
    }

    //移动拷贝运算符重载
    Test& operator = (Test&& other)noexcept //移动拷贝函数需要加
    {
        cout << " move copy operator =" << endl;
        this->m_ptr = other.m_ptr;
        other.m_ptr = nullptr;
    }
        
};

int main()
{
    Test t1;
    Test t2(1,2);
    Test t3 = 1; //隐式转换：将整型转为了Test类型
    //添加了explicit就会报错，不加不报错

    string s("hello world!");
    Test t4 = s; //隐式类型转换----危险，添加了explicit就会报错

    //正确做法：
    Test t5(s);
    Test t6(1);
    Test t7 = static_cast<Test>(1);
    
    cout << "hello world!\n";
    
    
    //匿名对象
    Test("hello world");
     
    Test t10 = getTest(); //调用的为移动拷贝构造函数
    Test t11 = (getTest()); //同上
    Test t12 = Test("hello world"); //匿名对象不会调用 
    return 0;
}

//输出先按顺序输出有参数与无参数构造函数等，最后有几个函数执行几次析构函数

析构函数：

析构函数：释放资源释放空间

特点：

1.无返回值

2.函数名为：~类名

3.无参

4.不能重载

5.当对象离开所在作用域释放空间时，先调用析构函数

.h文件

#pragma once

class Stack
{
    public:
        ~Stack();
}

.cpp文件

~Stack::~Stack() //用于释放函数，出了作用域自动调用
{
    delete [] stack;
    stack = nullptr;
}

this指针：

在类内，每实例化一个对象都有一个指针指向该对象的指针（this）

对象模型：每个对象都有自己独立的属性空间，属性指的是成员变量：按照成员变量所占空间的总和分配空间，共享代码空间（方法，函数）

作用：区别同一个类定义的不同实例

main.cpp

int main()
{
    Stack s1;
    Stack s2;
    Stack s3;
    //用一个类实例化三个对象
    
    s1.push(5);
    //如何知道访问的函数是访问哪个成员的数据？
    //系统内实际输入s1.push(5，&s1);在默认传参时会传入当前变量的地址this指针
}

Stack::Stack()//凡是通过this访问的都是自己的属性
{
    this->stack = new int[10];//标准写法加this
    this->maxLen = len;
    this->top = -1;
}

初始化列表：

一般在函数体内部给成员初始化

初始化列表真正实现的功能：定义并初始化（调用时机：先于构造函数），初始化效率优于构造函数体里初始化（不用发生函数调用）

必须在初始化列表初始化的：

const成员

引用

对象成员（无参构造函数） 实例时对象会自动调用构造函数（定义并初始化）

#include<iostream>

using namespace std;

class A
{
  public:
    int m_num;
    A(int num) : m_num(num)
    {
    }

    ~A()
    {
    }
        
};
class Test
{
    public:
        int m_num;
        char *ptr;
        const int count;//const 成员 只能在初始化列表中初始化
        int &r_num; //初始化会出错，为左值 只能在初始化列表中初始化
        int &&r_num; //引用就不报错
        A a; //对象成员(无参构造函数)
        
        Test()
        {
            this->m_num = 0;
        }

        Test(int num, char *ptr)
        {
            this-> m_num = num;
            this -> ptr = ptr;
        }

        //上下相同,下方使用初始化列表
        Test() : m_num(0)，count(0),r_num(0)，a(5)
        //r_num(m_num) 也可以
        {
            
        }

        Test(int num,char * ptr) :m_num(num),ptr(ptr)
        {
            
        }
};

喜之郎奚奚果冻
关注
专栏目录
详解C++中如何将构造函数或析构函数的访问权限定为private
09-02
在C++编程语言中，将构造函数或析构函数的访问权限设置为private是一种常见的设计模式，通常用于实现单例模式或者控制对象的创建和销毁。单例模式确保一个类在整个程序运行期间只存在一个实例。下面我们将详细探讨这...
C++智能指针实现（包含拷贝构造，赋值函数，引用解引用重载）
03-22
最后，析构函数在智能指针生命周期结束时被调用，它会递减`ref_count`，若`ref_count`为0，则释放内存。 在`Source.cpp`中，我们可以编写一些测试代码来验证这个智能指针的正确性，例如创建多个智能指针实例，赋值...
c++—封装：构造函数、析构函数、成员操作
m0_72814368的博客
05-25 1048
c++—封装、构造函数、析构函数
C++第五节 - this指针、构造函数、析构函数
weixin_47702917的博客
09-11 1065
此时会发现自定义类型_st被初始化，但是内置类型没有被初始化！
大话C++：第12篇 构造函数与析构函数
whccf的博客
09-24 1313
C++构造函数是一种特殊的成员函数，用于初始化类的对象。当创建对象时，构造函数会自动执行，且只执行一次。它主要用于设置对象的初始状态或执行一些必要的初始化操作。
C++入门：构造函数，析构函数，拷贝构造函数，运算符重载详解
zhang_si_hang的博客
05-15 2805
目录 类的6个默认成员函数 一.构造函数 1.概念 2.特征如下： 1. 函数名与类名相同。 2. 无返回值。 3. 对象实例化时编译器自动调用对应的构造函数。 4. 构造函数可以重载。 5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。 6. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。 7. 关于编译器生成的默认成员函数，很多同学会有疑惑： 8. （了解）C++11打的..
从0开始C++（三）：构造函数与析构函数详解
当实力撑不起野心的时候 学习才是唯一出路
06-20 1302
构造函数析构函数创建对象时手动调用当对象销毁时，自动调用函数名称是类名函数名称是~类名构造函数可以重载析构函数没有参数，不能重载用于创建对象时并初始化用于销毁对象时释放资源有返回值但是不写，返回值是新创建的对象没有返回值。
智能指针与析构函数
weixin_47695827的博客
08-26 924
智能指针还允许你指定一个自定义的删除器，这个删除器会在对象被释放时调用，而不是默认的。
C++析构函数解析（destructors）
shaozheng0503的博客
06-13 1060
综上所述，析构函数是为了解决程序中动态内存申请和管理的问题而存在的，它是一种特殊的函数，当对象生命周期结束时自动调用，主要用于清理对象所占用的资源、还原对象的状态等。总之，析构函数是类的一个特殊函数，在对象生命周期结束时自动调用（或者手动调用），它的主要作用就是清理对象所占用的资源，例如动态分配的内存、打开的文件等。此外，析构函数的另一个重要作用是帮助我们管理类中的各种数据结构和状态。通常我们可以使用析构函数来释放资源但需要注意的是，在大多数情况下，析构函数在对象被销毁时自动调用，程序员无需手动调用。
c++构造函数与析构函数,类对象的初始化
weixin_63096194的博客
04-22 1408
对象的内存分配,构造函数,析构函数.
类中的构造函数与析构函数、函数重载以及this指针的总结
NobodyZhou
07-02 1248
对C++类中的一些特性做些常识性的总结，增强对类的认识。分析了构造函数和析构函数的性质，函数重载以及this指针。需要注意理解的是 类 以及 类的对象 两者之间的关系，希望能更好的体会面向对象以及提升编程中抽象事物的能力。
C++ 构造/析构函数中的异常处理
banbanlin的专栏
09-23 2021
C++ 为什么会引入(需要)异常? The C++ Programming Language: 一个库的作者可以检测出发生了运行时错误，但一般不知道怎样去处理它们（因为和用户具体的应用有关）；另一方面，库的用户知道怎样处理这些错误，但却无法检查它们何时发生（如果能检测，就可以再用户的代码里处理了，不用留给库去发现）。 C++ primer: Exceptions let us se
构造与析构函数（csdn）————程序.pdf
12-05
然而，实际开发中，为避免内存泄漏，更推荐使用智能指针（如`std::unique_ptr`或`std::shared_ptr`）或容器（如`std::vector`）来管理内存，这些工具会在适当的时候自动调用析构函数并释放内存。 在定义类时，通常...
Word中数据的计算.pdf
10-11
Word中数据的计算.pdf
Microsoft Project Portfolio Server 2007 Datasheet_CN_Final.doc
10-11
Microsoft Project Portfolio Server 2007 Datasheet_CN_Final.doc
JaroWinklerSimilarity
10-11
Jaro-Winkler 相似度（Jaro-Winkler Similarity）是一种用于衡量两个字符串相似度的算法，特别适用于比较短字符串或需要考虑字符顺序的情况。它在信息检索、数据清洗和拼写校正等领域广泛应用。 主要特点 基本原理： Jaro-Winkler 相似度基于 Jaro 距离，这一距离主要考虑字符的匹配和顺序。 该算法首先计算两个字符串的匹配字符和匹配位置，以此计算相似度。 加权机制： Jaro-Winkler 在 Jaro 的基础上增加了对前缀匹配的奖励，这意味着如果两个字符串的开头部分相同，算法将给予更高的相似度评分。 结果范围： 相似度的值在 0 到 1 之间，1 表示完全相同，0 表示完全不同。
神经网络模型来检测肺炎的CT的影像
最新发布
10-11
神经网络模型来检测肺炎的CT的影像
20241011-0909
10-11
ffff
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值