当前位置：首页 > article >正文

Qt学习笔记第21到30讲

article 2024/10/24 1:15:40

第21讲 new/delete关键字

new关键字

在 C++ 中， new 关键字用于动态分配内存。它是 C++ 中处理动态内存分配的主要工具之一，允许在程序运行时根据需要分配内存。

用法

①分配单个对象：使用 new 可以在堆上动态分配一个对象。例如， new int 会分配一个 int 类型的空间，并返回一个指向该空间的指针。

   int* ptr = new int; //C语言中，int *p = (int *)malloc(sizeof(int));
   cout<<sizeof (*ptr)<<endl;

②分配对象数组： new 也可以用来分配一个对象数组。例如， new int[10] 会分配一个包含10个整数的数组。

   int *arr=new int[10];
   arr[0]=0;

③初始化：可以在 new 表达式中使用初始化。对于单个对象，可以使用构造函数的参数：

语法：

MyClass* obj = new MyClass(arg1, arg2);

示例：

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

using namespace std;

class Person
{
  private:
    string name;
    int    age;
  public:
    void printInfo(void);

    Person(string myName,int myAge)
    {
        this->name=myName;
        this->age=myAge;

    }
};

void Person::printInfo(void)
{
    cout<<"person's name:"<<this->name<<endl;
    cout<<"person's age:"<<this->age<<endl;
}

int main()
{
    Person* p1=new Person("Mike",18);
    (*p1).printInfo();



   return 0;
}

delete关键字

使用 new 分配的内存必须显式地通过 delete （对于单个对象）或 delete[] （对于数组）来释放，以避免内存泄露。

用法

①释放单个对象

delete ptr; // 释放 ptr 指向的对象

示例：

int main()
{
    Person* p1=new Person("Mike",18);
    (*p1).printInfo();
    delete p1;

   return 0;
}

②释放数组

delete[] arr; // 释放 arr 指向的数组

示例：

   int *arr=new int[10];
   delete[] arr;

注意事项

异常安全：如果 new 分配内存失败，它会抛出 std::bad_alloc 异常（除非使用了 nothrow 版本）。

内存泄露：忘记释放使用 new 分配的内存会导致内存泄露。

匹配使用 delete 和 delete[ ] ：为避免未定义行为，使用 new 分配的单个对象应该使用

delete 释放，使用 new[ ] 分配的数组应该使用 delete[ ] 释放。

第22\23讲拷贝构造函数与析构函数

参考拙作：C++语法补习课——对象特性-CSDN博客

第24讲静态成员

定义

静态成员在 C++ 类中是一个重要的概念，它包括静态成员变量和静态成员函数。静态成员的特点和存在的意义如下：

静态成员变量

1. 定义：静态成员变量是类的所有对象共享的变量。与普通成员变量相比，无论创建了多少个类的实例，静态成员变量只有一份拷贝。

2. 初始化：静态成员变量需要在类外进行初始化，通常在类的实现文件中。

3. 访问：静态成员变量可以通过类名直接访问，不需要创建类的对象。也可以通过类的对象访问。

4. 用途：常用于存储类级别的信息（例如，计数类的实例数量）或全局数据需要被类的所有实例共

享。

示例代码：

#include <iostream>

using namespace std;

class MyClass{
public:
    static int staticValue;

    MyClass()
    {
        staticValue++;
    }

    static int getValue()
    {
        return staticValue;
    }

};

//静态成员需要在类的外部实现初始化
int MyClass::staticValue=100;

int main()
{
    //静态成员变量可以通过类名直接访问，不需要创建类的对象
    cout<<"staticValue="<<MyClass::staticValue<<endl;
    return 0;
}

静态成员函数

1. 定义：静态成员函数是可以不依赖于类的实例而被调用的函数。它不能访问类的非静态成员变量和非静态成员函数。

2. 访问：类似于静态成员变量，静态成员函数可以通过类名直接调用，也可以通过类的实例调用。

3. 用途：常用于实现与具体对象无关的功能，或访问静态成员变量。

#include <iostream>

using namespace std;

class MyClass{
public:
    static int staticValue;
    int datas;

    //静态成员函数在对象实例化之前就已经存在
    static int getValue()
    {
        //datas作为普通成员变量需要实例化对象后才可以进行操作
        //datas++；
        return staticValue;
    }

};

//静态成员需要在类的外部实现初始化
int MyClass::staticValue=100;

//更多时刻，静态成员变量的作用是在不同类之间数据共享
class HisClass{
public:
    static void printInfo()
    {
        printf("staticValue=%d\n",MyClass::staticValue);
    }

};


int main()
{
    //静态成员变量可以通过类名直接访问，不需要创建类的对象
    cout<<"staticValue="<<MyClass::staticValue<<endl;
    int newValue=MyClass::staticValue+100;
    cout<<"newValue="<<newValue<<endl;
    HisClass::printInfo();

    return 0;
}

重要用法

静态成员的一个重要作用是帮助我们获取实例化对象的数量。

#include <iostream>

using namespace std;

class MyClass{
public:
    static int numofInstance;

    MyClass()
    {
        numofInstance++;
    }

    static int getNumofInstance()
    {
        return  numofInstance;
    }
};

int MyClass::numofInstance=0;

int main()
{
   MyClass member1;
   MyClass member2;
   MyClass member3;

   cout<<"Number of Instance:"<<MyClass::getNumofInstance()<<endl;
}

输出结果：

另外实例化的对象在程序运行超出作用域时会被自动销毁，如同下例：

#include <iostream>

using namespace std;

class MyClass{
public:
    static int numofInstance;

    MyClass()
    {
        numofInstance++;
    }

    ~MyClass()
    {
        numofInstance--;
    }

    static int getNumofInstance()
    {
        return  numofInstance;
    }
};

int MyClass::numofInstance=0;

int main()
{
   MyClass member1;
   MyClass member2;
   MyClass member3;

   cout<<"Number of Instance:"<<MyClass::getNumofInstance()<<endl;

   {
       MyClass m4;
       cout <<"Number of Instance:"<< MyClass::getNumofInstance() << endl;
       MyClass m5;
       cout <<"Number of Instance:"<< MyClass::getNumofInstance() << endl;
   }

   MyClass *mem=new MyClass;
   cout<<"Number of Instance:"<<MyClass::getNumofInstance()<<endl;
   delete mem;

   cout<<"Number of Instance:"<<MyClass::getNumofInstance()<<endl;


   system("pause");
   return 0;
}

输出结果为：

可以看到m4与m5在超出作用域后就被程序销毁。

第25讲继承

基本概念

继承是面向对象编程（ OOP ）中的一个核心概念，特别是在 C++ 中。它允许一个类（称为派生类或子类）继承另一个类（称为基类或父类）的属性和方法。继承的主要目的是实现代码重用，以及建立一种类型之间的层次关系。

特点

1.代码重用：子类继承了父类的属性和方法，减少了代码的重复编写。

2. 扩展性：子类可以扩展父类的功能，添加新的属性和方法，或者重写（覆盖）现有的方法。

3. 多态性：通过继承和虚函数， C++ 支持多态，允许在运行时决定调用哪个函数。

代码示例

基本语法B继承A

class 派生类\子类B ： [权限声明] 基类\父类A

备注：权限声明是指private、public或者protected。

#include <iostream>
#include <string.h>
using namespace std;

class Vehicle
{
  public:
  string type;
  string country;
  string colour;
  double price;
  int    numofVehicle;

  void run()
  {
      cout<<Vehicle::type<<"正在行驶..."<<endl;
  }
  void stop();

};

class Roadster :public Vehicle
{
    public:

    void openTopped();
    void pdrifting();

};

class Motobike :public Vehicle
{
  public:
    void charge();

};


int main()
{
    Roadster fType;
    fType.type="捷豹";
    fType.run();

    Motobike aType;
    aType.type="铃木";
    aType.run();

    return 0;
}

输出结果：