QT的基础学习笔记（一）

类

类用于指定对象的格式，它包含了数据表明的手法和用于处理数据的方法。类中的数据和方法称为类的成员。简单的理解就是‘类’是同一类对象的命名。例如

class Dog{//定义一个Dog的抽象类,其中一条狗的名字，年龄，体重这些属性就是它的成员
	public: 
	string name;
	int age;
	int weight;
};

类中实例化对象的方法

1）从栈中实例化对象
例如：Dog dog；
2）从堆中实例化对象（需要手动释放空间）
例如：Dog *dog；
内存这方面有点类似c语言中的管理方法，也有点不同，在c语言中要将数据存放在堆区中需要用malloc函数。

构造函数和析构函数

构造函数

构造函数在对象实例化时被系统自动调用，仅且调用一次。
1）构造函数必须与类名同名；
2）可以重载；
3）类名（）可以加参数；
4）没有返回类型，即使是void也不行。

构造函数的定义

类名：：类名
例：

Dog::Dog(){}

析构函数

与构造函数相反，在对象结束其生命周期时系统自动执行析构函数
1）析构函数的格式为~类名（）；
2）调用时释放内存；
3）~类名（）不能加参数；
4）没有返回值，即使是void也不行。

析构函数的定义

类名：：~类名（）
例:

Dog::~Dog(){}

继承

继承允许依据一个类来定义另外一个类
新创建的类被成为派生类，而已有的类叫做基类。

定义继承格式如下：

class derived-class:class-specifier base-class
derived-class是定义的派生类名称
base-class是已有的基类名称

继承成员分类

1、公有继承（public)：当一个类派生继承公有基类时，基类的公有成员也是派生类的公有成员。
2、保护继承（protected）：当一个类派生继承保护基类时，基类的公有和保护成员将成为派生类的保护成员。
3、私有继承（）：当一个类派生继承私有基类时，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。

#include <iostream>
#include <string>
using namespace std;
class Animal{
    private:
    int age;
    public:
    string color;

};
class Dog:public Animal{
    private:
    public:
    string name;
};

int main(){
    Dog dog;
   dog.color="yellow";
   dog.name="旺财";
   cout<<"名称："<<dog.name<<endl;
   cout<<"颜色："<<dog.color<<endl;
    return 0;
}

重载

函数重载

#include <iostream>
#include <string>
using namespace std;
class Dog
{
public:
	string name;
	void getWeight(int weight){
		count<<""<<endl;
	}
	void getWeight(double weight){
		count<<""endl;
	}
}

int main(){
	Dog dog;
	dog.name="曹总";
	dog.getWeight(10);
	dog.getWeight(10.5);
	return 0;
}

多态

形成多态的三个条件：
1、必须存在继承关系；
2、继承关系必须有同名虚函数（其中虚函数是在基类中使用关键字 virtual 声明的函数，在派 生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数）；
3、存在基类类型的指针或者引用，通过该指针或引用调用函数。

虚函数

是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时， 会告诉编译器不要静态链接到该函数。我们想要的是在程序中任意点可以根据所调用的对象类 型来选择调用的函数，这种操作被称为动态链接，或后期绑定。虚函数声明如下：virtual ReturnType FunctionName(Parameter) 虚函数必须实现，如果不实现，编译器将报错。

纯虚函数

若在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是您在基 类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。纯虚函数声明如下： virtual void funtion1()=0; 纯虚函数一定没有定义，纯虚函数用来规范派生类的行为，即接口。 包含纯虚函数的类是抽象类，抽象类不能定义实例，但可以声明指向实现该抽象类的具体类的 指针或引用。

#include <iostream>
#include <string>
using namespace std;
class Animal{
    public:
    virtual void run();//定义一个虚函数

};
class Dog:public Animal{
    
    public:
    void run();
    
};
class Cat:public Animal{
    public:
    void run();
};
void Dog::run(){
    cout << "狗的方法"<< endl;
}
void Cat::run(){
    cout << "猫的方法"<< endl;
}
int main(){
    Animal *animal;//声明一个Animal的指针对象 没有实体化它
   Dog dog;//实体化一个Dog的对象
   Cat cat;//实体化一个Cat的对象
   animal=&dog;//指针对象指向实体化的dog对象的地址
   animal->run();//调用run方法
   animal=&cat;//指针对象指向实体化的cat对象的地址
   animal->run();//调用run方法
    return 0;
}

数据封装

数据封装是一种把数据和操作数据的函数捆绑在一起的机制

#include <iostream>
#include <string>
using namespace std;
class Dog{
    public:
    string name;
    Dog(int i=0){
        totle=i;
    }
    void addFood(int number){
        this->totle=this->totle+number;
    }
    int getFood(){
        return this->totle;
    }
    private:
     int totle;
};
int main(){
    Dog dog;
    dog.addFood(5);
    cout<<"第一次喂食："<<dog.getFood()<<endl;
    dog.addFood(10);
    cout<<"第二次喂食："<<dog.getFood()<<endl;
    return 0;
}

当一个类继承后就可以通过继承公有的数据封装来改变，私有继承的数值。

接口（抽象类）

如果类中至少有一个函数被声明为纯虚函数，则这个类就是一个抽象类。

#include <iostream>
#include <string>
using namespace std;
//定义一个Animal的抽象类型
class Animal{
    public:
    virtual void run()=0;//定义一个run()的纯虚函数
};
class Cat{
    public:
    void run(){//
        cout<<"猫的方法"<<endl;
    }
};
class Dog{
    public:
    void run(){//
        cout<<"狗的方法"<<endl;
    }
};

int main(){
    Dog dog;
    dog.run();
    Cat cat;
    cat.run();
    return 0;
}