投稿
  1. 高性能架构探索首页
  2. C/C++

C/C++ 类与构造析构等知识

admin • • C/C++ • 阅读 131

简单定义类

#include <iostream>
#include <string>

using namespace std;

class Student
{
public:
    int uid;
    char *name;
    int age;

public:
    void set(int id, char *name, int age)
    {
        this->uid = id;
        this->name = name;
        this->age = age;
    }
    void display()
    {
        cout << this->uid << this->name << this->age << endl;
    }
};

void Call(const Student &ptr)
{
    cout << ptr.name << endl;
}

int main(int argc, char *argv[])
{
    Student stu;   // 实例化

    stu.set(1001, "lyshark", 23);                     // 设置数据
    cout << stu.uid << stu.name << stu.age << endl;   // 输出
    stu.display();                                    // 使用成员函数输出

    Student *ptr = &stu;           // 使用指针
    cout << ptr->uid << ptr->name << ptr->age << endl;

    Call(stu);
    system("pause");
    return 0;
}

构造/析构 函数: 构造函数与类名相同，没有返回值，不写void，可以发生重载，可以有参数

#include <iostream>
#include <string>

using namespace std;

class Student
{
public:
    int uid;
    char *name;
    int age;

public:
    Student(int uid,char *name,int age)     // 构造函数
    {
        this->uid = uid;
        this->name = name;
        this->age = age;
    }
    ~Student()                              // 析构函数
    {
        cout << "执行结束,析构 !" << endl;
    }
    void Display()
    {
        cout << this->name << endl;
    }

};

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

    class Student *stu_ptr[3];

    Student stu1(1001, "admin", 22);
    Student stu2(1002, "guest", 33);
    Student stu3(1003, "tudyit", 25);

    stu_ptr[0] = &stu1;
    stu_ptr[1] = &stu2;
    stu_ptr[2] = &stu3;

    for (int x = 0; x < 3; x++)
        stu_ptr[x]->Display();

    system("pause");
    return 0;
}

析构函数，没有返回值，不可以写参数，不能发生重载，多用于最后的类的清理左右。

无参数构造函数（默认构造函数），有参数

拷贝构造函数:

#include <iostream>
#include <string>

using namespace std;

class Student
{
public:
    int uid;
    char *name;
    int age;

public:
    Student(int uid,char *name,int age)     // 构造函数
    {
        this->uid = uid;
        this->name = name;
        this->age = age;
    }
    Student(const Student& ptr)             // 拷贝构造函数
    {
        name = ptr.name;                    // 将 拷贝参数赋值给被拷贝类中
        cout << "kaobei" << endl;
    }
};

int main(int argc, char *argv[])
{
    Student stu1(1001, "admin", 22);

    // 拷贝构造函数：括号法调用
    // 调用拷贝构造函数 stu1 拷贝到stu2中
    Student stu2(stu1);
    cout << stu2.name << endl;

    Student stu3 = Student(stu1);
    cout << stu3.name << endl;

    system("pause");
    return 0;
}

浅拷被： 容易崩溃，系统简单的传值，出现问题。

#include <iostream>
#include <string>

using namespace std;

class Student
{
public:
    char * m_name;
    int m_age;

public:
    Student()
    {

    }
    Student(char * name, int age)
    {
        m_name = (char *)malloc(strlen(name) + 1);
        strcpy(m_name, name);
    }
    ~Student()
    {
        if (m_name != NULL)
            free(m_name);
    }

};


int main(int argc, char *argv[])
{
    Student stu1("lyshark",25);
    // < 浅拷贝,出现了崩溃的问题> 因为执行了两次析构，出现了冲突
    Student stu2(stu1);            // 调用拷贝构造函数

    system("pause");
    return 0;
}

深拷贝： 自己开辟堆空间，然后自己在拷贝构造函数中拷贝数据，防止冲突，同样的代码不会出现问题了。

#include <iostream>
#include <string>

using namespace std;

class Student
{
public:
    char * m_name;
    int m_age;

public:
    Student()
    {

    }
    Student(char * name, int age)
    {
        m_name = (char *)malloc(strlen(name) + 1);
        strcpy(m_name, name);
    }
    ~Student()
    {
        if (m_name != NULL)
            free(m_name);
    }
    Student(const Student &ptr)
    {
        m_age = ptr.m_age;
        m_name = (char *)malloc(strlen(ptr.m_name) + 1);
        strcpy(m_name, ptr.m_name);     // 深层拷贝
    }
};

int main(int argc, char *argv[])
{
    Student stu1("lyshark",25);
    // < 浅拷贝,出现了崩溃的问题> 因为执行了两次析构，出现了冲突
    Student stu2(stu1);            // 调用拷贝构造函数

    system("pause");
    return 0;
}

多个对象的构造和析构：初始化列表

#include <iostream>
#include <string>

using namespace std;

class Student
{
public:
    char * m_name;
    int m_age;

public:
    Student(char * x, int y) :m_name(x), m_age(y){}
};


int main(int argc, char *argv[])
{
    Student stu("lyshark",23);
    cout << stu.m_name << stu.m_age << endl;


    system("pause");
    return 0;
}

explicit 关键字的作用 该关键字为了防止隐世类型转换,就是防止你瞎搞。

#include <iostream>
#include <string>

using namespace std;

class MyString
{
public:
    char * m_Str;

public:
    MyString(const char *str)
    {

    }
    // 该关键字为了防止隐世类型转换
    explicit MyString(int num)
    {

    }

};


int main(int argc, char *argv[])
{
    MyString str = "lyshark";    // 显示调用

    // MyString str2 = 10;

    system("pause");
    return 0;
}

new 动态对象创建: 忘记 malloc() /free 吧，new 可以自动分配初始化空间，非常方便。开辟空间到堆。

#include <iostream>
#include <string>

using namespace std;

class Student
{
public:
    char * m_Str;

public:
    Student()
    {
        cout << "默认构造调用" << endl;
    }
    ~Student()
    {
        cout << "默认析构调用" << endl;
    }
};


int main(int argc, char *argv[])
{
    // Student stu1;        // 在站区开辟空间

    // 所有new出来的对象都会返回该类型的指针
    // malloc 返回 void* 还必须要强转
    // new 会调用构造函数? new 并不是函数而是运算符

    Student *stu2 = new Student;   // 堆区开辟空间
    // 释放堆空间
    delete stu2;

    // new 来开辟数组 , 他一定会调用默认构造函数，有多少数组成员就调用多少次！
    Student *pArray = new Student[10];

    pArray[0].m_Str = "lyshark";

    cout << pArray[0].m_Str << endl;

    // 释放整个数组,必须加[] 中括号
    delete [] pArray;


    system("pause");
    return 0;
}

静态成员变量: static声明就是静态成员变量，无论建立多少对象，都只有一个静态数据的拷贝，所有对象都共享这个静态数据。

#include <iostream>

using namespace std;

class Student
{
public:
    // 静态成员变量,在类内声明，在类外初始化
    static int m_number;  // 定义静态变量
};

int Student::m_number = 100;      // 类外初始化实现

int main(int argc, char *argv[])
{
    Student stu1, stu2;

    stu1.m_number = 200;  // stu1赋值后,会影响stu2里面的,两个是共享数据的

    cout << stu1.m_number << endl;
    cout << stu2.m_number << endl;
    cout << "通过类名直接访问:"<< Student::m_number << endl;

    system("pause");
    return 0;
}

静态成员函数:

#include <iostream>

using namespace std;

class Student
{
public:
    static void Display()
    {
        cout << "hello lyshark" << endl;
    }
};


int main(int argc, char *argv[])
{
    Student stu1,stu2;

    // 静态成员函数,不可以访问普通成员变量
    // 但是可以访问静态成员变量

    stu1.Display();     // 两个对象同样是调用的一个函数。
    stu2.Display();

    system("pause");
    return 0;
}

单例模式设计思想： 一个类中，是能实例化出一个对象，这样就可以防止冲突的情况发生。

想想，如何实现，不论new多少次，始终只能保证，创建一个对象，不多创建。

#include <iostream>

using namespace std;

// 创建列中的对象，并且保证只有一个对象可以使用，一个对象实例。

class ChairMan
{
private:
    // 1.将构造函数自由化，改成private
    // 
    ChairMan(){ cout << "create super" << endl; }
public:
    static ChairMan *singleMan;

};

ChairMan * ChairMan::singleMan = new ChairMan;

int main(int argc, char *argv[])
{
    cout << "main" << endl;  // 主席创建，先于 main
    ChairMan::singleMan;

    ChairMan *cm1 = ChairMan::singleMan;



    system("pause");
    return 0;
}

安全的改进

#include <iostream>

using namespace std;

// 创建列中的对象，并且保证只有一个对象可以使用，一个对象实例。

class ChairMan
{
private:
    // 1.将构造函数自由化，改成private
    // 
    ChairMan(){ cout << "create super" << endl; }
    ChairMan(const ChairMan &ch) {};
private:
    static ChairMan *singleMan;
public:
    // 通过提供的接口实现访问
    static ChairMan* getInstance()
    {
        return singleMan;
    }
};

ChairMan * ChairMan::singleMan = new ChairMan;

int main(int argc, char *argv[])
{
    ChairMan * cm1 = ChairMan::getInstance();
    ChairMan * cm2 = ChairMan::getInstance();
    if (cm1 == cm2)
        cout << "相等" << endl;

    // 现在其实也能改? 下面可以强改,加上拷贝构造，直接完事。
    ChairMan *cm3 = new ChairMan(*cm2);
    if (cm2 == cm3)
        cout << "不相等" << endl;


    system("pause");
    return 0;
}

打印机的单例模式案例。

#include <iostream>
#include <string>

using namespace std;

class Printer
{
private:
    static Printer * singlePrinter;

private:
    Printer(){ };
    Printer(const Printer & ptr);

public:
    static Printer * getInstance()
    {
        return singlePrinter;
    }
    static void PrintText(string text)
    {
        cout << text << endl;
    }
};

Printer * Printer::singlePrinter = new Printer;


int main(int argc, char *argv[])
{
    // 拿到打印机对象指针,后期通过该指针操作数据
    Printer * ptr = Printer::getInstance();

    ptr->PrintText("hello lyshark");   // 调用打印机

    system("pause");
    return 0;
}

this 指针: this指针指向被调用的成员函数所属的对象，

#include <iostream>
#include <string>

using namespace std;

class Person
{
public:
    char *name;
    int age;

public:
    Person(char *p_name, int p_age) { this->name = p_name; this->age = p_age; }

    void Compare_Age(Person & ptr)       // 对比年龄是否相等
    {
        if (this->age == ptr.age)
            cout << "Same age" << endl;     // 年龄相同
        else
            cout << "Same not age" << endl; // 年龄不同
    }

    void PlusAge(Person & ptr)   // 两个年龄相加
    {
        this->age += ptr.age;
    }

    Person & Push_Age(Person &ptr)
    {
        this->age += ptr.age;
        return *this;         // 返回指向对象本体
    }

};

int main(int argc, char *argv[])
{
    Person per1("lyshark", 33);
    Person per2("admin", 33);
    // ----------------------------------------
    per1.Compare_Age(per2);      // 判断两个类年龄是否相等
    // ----------------------------------------
    per1.PlusAge(per2);          // 将两个年龄相加
    cout << per1.age << endl;    // 输出年龄
    // ----------------------------------------

    per1.Push_Age(per2).Push_Age(per2);  // 链式编程(必须传递引用)
    cout << per1.age << endl;

    system("pause");
    return 0;
}

空指针访问成员函数: 如果用不到this则可以调用，用到的话就会报错。

#include <iostream>
#include <string>

using namespace std;

class Person
{
public:
    int m_age;

public:
    void show() { cout << "person show" << endl; }
    void show_age() 
    {
        if (this == NULL)   // 防止使用空指针访问
            return;
        cout << "show: "<< m_age << endl;
    }
};

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

    Person *ptr = NULL;

    ptr->show();          // 这个可以
    ptr->show_age();      // 不可以

    // show_age() 默认会加上 this --> 那么如果传递空指针则失败
    // 代码接收空指针,会溢出

    system("pause");
    return 0;
}

常函数、常对象： 使用const 修饰成员函数，则是常函数，

#include <iostream>
#include <string>

using namespace std;

class Person
{
public:
    int m_x;
    int m_y;

public:
    Person()
    {
        this->m_x = 0;
        this->m_y = 0;
    }

    void showInfo() const // 声明常函数,函数内部不可有修改指针的指向
    {
         // this->m_x = 1000; 相当于修改成了: --> const Person * const this
        cout << this->m_x << endl;
        cout << this->m_y << endl;
    }
};


int main(int argc, char *argv[])
{
    Person per1;
    per1.showInfo();

    // 定义常对象，常对象不允许修改数据。
    const Person per2;

    system("pause");
    return 0;
}

友元函数的定义(全局函数): 将全局函数定义为友元函数，让外部函数，可以访问类内部的私有数据。

#include <iostream>
#include <string>

using namespace std;

class Building
{

    friend void goodGay(Building *building);
private:
    string m_badRoom;        // 私有的卧室
    string m_sittingRoom;    // 客厅

public:
    Building()
    {
        this->m_sittingRoom = "客厅";
        this->m_badRoom = "卧室";
    }
};

// 全局函数,我想让他能访问到私有的卧室
void goodGay(Building *building)
{
    cout << "访问我的客厅:" << building->m_badRoom << endl;
    cout << "访问我的卧室:" << building->m_sittingRoom << endl;

}

int main(int argc, char *argv[])
{
    Building *building = new Building;
    goodGay(building);


    system("pause");
    return 0;
}

让整个类做友元类:

#include <iostream>
#include <string>

using namespace std;

class Teacher
{
    friend class Student;  // 让Student学生,可以访问我的私有成员

private:
    char * m_school;     // 老师所在的学校
    char * m_class;      // 老师所教的班级

public:
    Teacher()
    {
        this->m_school = "中心小学";
        this->m_class = "一年级二班";
    }
};

class Student
{
private:
    Teacher *ptr;         // 设置一个指向teacher的指针

public:
    Student()
    {
        ptr = new Teacher; // 初始化一下
    }
    void Display()
    {
        cout << "学生访问到的学校: " << this->ptr->m_school << endl;
        cout << "学生访问到的班级: " << this->ptr->m_class << endl;
    }
};

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

    Student stu;
    stu.Display();

    system("pause");
    return 0;
}

原文链接: https://www.cnblogs.com/LyShark/p/12874267.html

欢迎关注

微信关注下方公众号，第一时间获取干货硬货；公众号内回复【pdf】免费获取数百本计算机经典书籍;

也有高质量的技术群，里面有嵌入式、搜广推等BAT大佬

    C/C++ 类与构造析构等知识

原创文章受到原创版权保护。转载请注明出处：https://www.ccppcoding.com/archives/348013

非原创文章文中已经注明原地址，如有侵权，联系删除

关注公众号【高性能架构探索】，第一时间获取最新文章

转载文章受原作者版权保护。转载请注明原作者出处！

赞 (0)
adminadmin
0 0
上一篇 2023年3月2日 上午4:50
下一篇 2023年3月2日 上午4:50

相关推荐