Qt和C++笔记-创新互联
ctrl + r 运行
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
//如果形参的两种类型不同，可以使用函数模板强制转换，Swap
//函数模板也可以重载
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()
{
//不能直接使用无参构造，不会自动转换类型，不知道该转换什么类型
//所以使用类模板的使用，调用必须指定类型
Data
ob1.test();
Data
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
{
cout<
}
void main()
{
//不能直接使用无参构造，不会自动转换类型，不知道该转换什么类型
//所以使用类模板的使用，调用必须指定类型
Data
ob1.test();
Data
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
{
size = 0;
capacity = 5;
arr = new T[capacity];
memset(arr,0,sizeof(T)*capacity);
}
template
Array
{
this->capacity = capacity;
size = 0;
arr = new T[capacity];
memset(arr,0,sizeof(T)*capacity);
}
template
Array
{
//拷贝构造函数，就对象给新对象赋值
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
{
delete []arr;
}
template
Array
{
//判断旧空间是否为空
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
{
//是否满
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://scyanting.com/article/jhish.html
