Qt和C++笔记-创新互联

QT调试快捷键:

ctrl + r 运行

创新互联主要从事网站设计制作、成都做网站、网页设计、企业做网站、公司建网站等业务。立足成都服务甘泉,十多年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:028-86922220

F5 断点调试,切换断点

F10 进入下一行

F11 进入函数内部

shift + F11 跳出函数

Qtxml相关:

DOM:提供一个接口来访问和改变xml文件中的内容,xml就像是一个有层次的树形视图,可以方便的对xml进行增删改查

SAX:基于事件的标准接口,适用于不需要对文档进行操作,只需要读取整个xml文档

g_root = g_doc.documentElement(); 获取全部的一级目录

QDomNodeList currencyNodes = element.childNodes(); 获取全部的二级目录

QDomNodeList child = apiNodes.at(0).childNodes(); 获取全部的三级目录

XML:可扩展性标记语言

传输和存储数据,不是展示数据。

xml标签自定义,写标签名的要有含义。

根节点

标签自定义

xml标签区分大小写,不可以交叉;

属性就是表示标签以外的额外信息,比较鸡肋

xml和HTML的区别:

xml标签成对出现,HTML要求不严格

xml用于存储和传输,HTML用于展示

xml标签自定义,HTML不行

xml头声明:

C++笔记进阶篇: 虚函数和纯虚函数

虚函数是为了实现多态,所谓多态就是一个接口有多种实现的方法,多态实现基类必须要有虚函数,子类对虚函数重写,当然也可以不重写,但是纯虚函数必须重写,实现多态就是基类的指针指向子类的对象,从而可以实现对子类的调用。

纯虚函数和虚函数差不多,在基类中不可以实现,只能声明,子类中重写,实现多态。

virtual void fun()=0;

虚析构:在父类析构函数前加virtual关键字,当delete父类指针指向的对象时就会释放子类的析构函数。

纯虚析构和虚析构的区别:纯虚析构必须类内声明加virtual,类外实现,Base::~Base(){};

深浅拷贝

类的深浅拷贝,当类中有指针成员时,当旧对象给新对象初始化就会调用拷贝构造函数,Data ca1(10); Data ca2 = ca1;

调用的拷贝构造函数形式为:Data(const Data &ob){ma = ob.ma; cout<<"拷贝构造函数"}

当类中成员含有指针成员时,需要给对象申请独立的地址空间,Data(const Data &ob){name = new char[strlen(ob.name)+1];strcpy(name,ob.name);cout<<"堆区的拷贝构造函数"}

结构体深浅拷贝:浅拷贝:当结构体成员无指针成员时使用,如果含有指针成员,会存在多次释放的问题

深拷贝:当结构体中含有指针成员时,要申请独立的地址空间,实现strcpy后,单独释放

构造函数和析构函数

构造函数和析构函数:构造函数是将对象初始化,可以有参无参,不能有返回值。析构函数将对象清理,有参和无参类型,自动调用

当一个类中含有另一个类名的成员时,会先初始化另一个类的构造函数,再调用自身的构造函数,

先释放自身的析构函数,再释放另一个类的析构函数,class Data{ ob(a); }

类中定义的函数,可以在类外使用ALT+ENTER实现,或者在类外(类名::函数名)实现

重载和重写

重载是在基类中定义相同的方法名,参数不同。重写是基类重写父类的方法,函数名和参数相同。

重载是在一个类中,重写是子类与父类之间

重载是编译时,重写发生在运行时

重载的参数类型,参数个数,参数顺序可以不同,重写子类和父类方法必须相同

重载对返回类型没有要求,重写有要求返回类型

单例模式:

当一个类中含有静态成员时,静态成员是先于所有对象存在的,不需要实例化对象,可以直接通过类名调用,静态成员在类中定义,在类外初始化

普通成员和普通成员函数必须要通过对象调用,一个类中的静态成员和成员函数是被其他所有对象共享的,即一个对象成员发生修改时,其他对象调用时也会改变

class Data{public:static int a;} int Data::a = 100; Data A1; A1.a/Data::a;

只允许该类实例化一个对象,如何实现:将构造函数和析构函数私有化,所以只能在类的内部私有实例化,使用static 类名 * const p;//p保存实例化地址 初始化:类名 *const::p = new 类名(创建唯一的实例)

定义一个公有的静态成员函数,获取实例化地址,static 类名 *getAdress(){}

主函数中使用 类名 *p1 = 类名::静态成员函数;

this指针:当类中的成员变量和成员函数形参重名时,使用this->ma=ma; 非静态成员都默认含有this指针

C++高阶部分 继承

子类继承父类的成员和方法,不能继承构造和析构,重载,赋值运算符

public保持不变,private不可以被继承,protected只能在子类访问,不能在类外访问

格式: class son : public Base

当子类和父类出现同名的成员时,可以使用加作用域区分 (不加优先调用子类)

多继承格式:class son : public Base1,public Base2

C++多态(父类指针指向子类空间)

静态多态,编译时发生(早绑定)【函数重载,运算符重载,重定义】

动态多态,运行时发生(晚绑定)【虚函数】

如果子类和父类出现相同的方法,父类指针指向子类对象时,调用父类的方法。

Base *ob = new Son; ob.func();

所以就要在父类成员函数前加virtual 子类可加可不加,实现多态,也就是

动态绑定机制:当出现virtual关键字,就会生成虚函数指针,虚函数指针查找对应的虚函数表,查找函数的入口地址,如果没有继承,会指向父类的函数入口地址。

如果有继承,子类继承父类的虚函数指针和虚函数表,查找子类的函数入口地址,指向子类的成员函数

重载重写重定义的区别:

  • 重载函数名必须相同,参数列表,返回值类型可以不同。(发生在一个类中)

  • 重写函数名,返回值类型,参数列表都要相同,子类重写父类的虚函数或纯虚函数,多用于多态中。(发生在子类和基类中)

  • 重定义就是子类和父类函数名相同,参数不同,不管有无virtual,都会屏蔽父类函数;参数相同时,如果没有virtual,也会屏蔽父类函数,如果有virtual就是重写。(发生在子类和基类中)

纯虚函数实例:

煮咖啡和煮茶叶都有,煮水,加入主料,加入辅料等操作

父类将通用的方法定义为纯虚函数,然后使用一个普通函数调用这些步骤

煮咖啡的子类重写父类的纯虚函数,煮茶叶的子类重写父类的纯虚函数。

主函数两种调用方式1.父类指针指向子类对象2.外部定义一个void test(基类名 * p){p->普通函数;delete p;} test(new tea);test(new coffee);

模板 函数模板(泛型编程)
  • 将功能相同类型不同的函数或类抽象成虚拟的类型,编译器自动将虚拟的类型具体化,提高代码重用性

  • 函数模板 要有template关键字修饰 关于T的类型会从主函数的实参中获取作相应的改变

  • 函数模板会编译两次,一次对函数模板本身,一次在函数调用时

//当函数模板和普通函数都存在时会优先调用普通函数

//也可以指定调用模板函数 Swap<>(a,b); 也可以直接告诉模板类型 Swap(a,b)

//如果形参的两种类型不同,可以使用函数模板强制转换,Swap(10,'a')

//函数模板也可以重载

template

void Swap(T &a, T &b)

{

T tmp;

tmp=a;

a=b;

b=tmp;

return ;

}

template

void test(T &a)

{

cout<

}

template

void test(T &a,T &b)

{

cout<

}

//当遇到结构体,自定义类型的时候,识别不到就可以使用函数模板具体化

template

void test(T &a,T &b)

{

cout<

}

class data

{

int a;

friendly void test(data a,data b);

}

//函数模板具体化

template void test(data a,data b)

{

}

int main()

{

int a=10,b=20;

Swap(a,b);

char a='B',b='A';

Swap(a,b);

return 0;

}

类模板
  • 使用类模板时将声明和定义的文件改为.hpp文件

template

class Data

{

private:

T1 a;

T2 b;

public:

Data();

Data(T1 a,T2 b)

{

this->a = a;

this->b = b;

}

void test()

{

cout<<""endl;

}

};

void main()

{

//不能直接使用无参构造,不会自动转换类型,不知道该转换什么类型

//所以使用类模板的使用,调用必须指定类型

Dataob1(10,20);

ob1.test();

Dataob2(10,'a');

ob2.test();

}

//在类外实现的类模板也要有template关键字

template

class Data

{

private:

T1 a;

T2 b;

public:

Data();

Data(T1 a,T2 b)

{

this->a = a;

this->b = b;

}

void test();

};

template

void Data::test()

{

cout<

}

void main()

{

//不能直接使用无参构造,不会自动转换类型,不知道该转换什么类型

//所以使用类模板的使用,调用必须指定类型

Dataob1(10,20);

ob1.test();

Dataob2(10,'a');

ob2.test();

}

数组模板

template

class Array

{

private:

T *arr;//地址

int size;//数组大小

int capacity;//数组容量

public:

Array();//无参

Array(int capacity);//有参

//类中有指针成员所以要深拷贝

Array(const Array &ob);

~Array();//析构函数

Array& operator =(Array &ob);//重写 赋值运算符深拷贝

void pushBack(int elm);//插入元素

void sortArray();//排序

};

#endif // ARRAYCLASS_HPP

template

Array::Array()

{

size = 0;

capacity = 5;

arr = new T[capacity];

memset(arr,0,sizeof(T)*capacity);

}

template

Array::Array(int capacity)

{

this->capacity = capacity;

size = 0;

arr = new T[capacity];

memset(arr,0,sizeof(T)*capacity);

}

template

Array::Array(const Array &ob)

{

//拷贝构造函数,就对象给新对象赋值

capacity = ob.capacity;

size=ob.size;

arr = new T[capacity];

memset(arr,0,sizeof(T)*capacity);

//要把就得内容拷贝到新的空间

memcpy(arr,ob.arr,sizeof(T)*capacity);

}

template

Array::~Array()

{

delete []arr;

}

template

Array&Array::operator =(Array &ob)

{

//判断旧空间是否为空

if(arr !=NULL)

delete []arr;

capacity = ob.capacity;

size=ob.size;

arr = new T[capacity];

memset(arr,0,sizeof(T)*capacity);

memcpy(arr,ob.arr,sizeof(T)*capacity);

return *this;//返回this的对象

}

template

void Array::pushBack(int elm)

{

//是否满

if(size == capacity)

{

capacity = 2*capacity;

T *tmp = new T[capacity];

//

if(arr != NULL)

{

memcpy(tmp,arr,sizeof(T)*capacity);

delete []arr;

}

arr = tmp;

}

arr[size] = elm;

}

你是否还在寻找稳定的海外服务器提供商?创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源,准确流量调度确保服务器高可用性,企业级服务器适合批量采购,新人活动首月15元起,快前往官网查看详情吧


新闻名称:Qt和C++笔记-创新互联
本文来源:http://pwwzsj.com/article/jhish.html