对象模型&模板

#define _CRT_SECURE_NO_WARNINGS 1


虚函数表是通过一块连续内存来存储虚函数的地址
//#include<iostream>
//#include<stdlib.h>
//
//using namespace std;
//
//class Base
//{
//public:
// virtual void func1()
// {
// cout << "Base::func1" << endl;
// }
// virtual void func2()
// {
// cout << "Base::func2" << endl;
// }
//private:
// int a;
//};
//
//class Derive:public Base
//{
// virtual void func1()//重写1
// {
// cout << "Derive::func1" << endl;
// }
// virtual void func3()
// {
// cout << "Derive::func3" << endl;
// }
// virtual void func4()
// {
// cout << "Derive::func4" << endl;
// }
//private:
// int b;
//};
//
//typedef void(*FUNC)();
//
//void printVTable(int *VTable)
//{
// cout << "虚表地址>" << VTable << endl;
// for (int i = 0; VTable[i] !=0; ++i)
// {
// printf("第%d个虚函数地址：0X%x,->", i, VTable[i]);
// FUNC f = (FUNC)VTable[i];
// f();
// }
// cout << endl;
//}
//void Test()
//{
// Base b1;
// Derive d1;
//
// int *VTable1 = (int*)(*(int*)&b1);
// int *VTable2 = (int*)(*(int*)&d1);
//
// printVTable(VTable1);
// printVTable(VTable2);
//}
//int main()
//{
// Test();
// system("pause");
// return 0;
//}




多继承下的内存布局
//#include<iostream>
//#include<stdlib.h>
//#include<stdio.h>
//
//using namespace std;
//
//class Base1
//{
//public:
// virtual void func1()
// {
// cout << "Base1::func1" << endl;
// }
// virtual void func2()
// {
// cout << "Base1::func2" << endl;
// }
//private:
// int b1;
//};
//
//class Base2
//{
//public:
// virtual void func1()
// {
// cout << "Base2::func1" << endl;
// }
// virtual void func2()
// {
// cout << "Base2::func2" << endl;
// }
//private:
// int b2;
//};
//
//class Derive :public Base1, public Base2
//{
//public:
// virtual void func1()//重写1
// {
// cout << "Derive::func1" << endl;
// }
// virtual void func3()
// {
// cout << "Derive::func3" << endl;
// }
//private:
// int d1;
//};
//
//typedef void(* FUNC)();
//
//void printVTable(int *VTable)
//{
// cout << "虚表地址>" << VTable << endl;
//
// for (int i = 0; VTable[i] != 0; ++i)
// {
// printf("第%d个虚函数地址：0X%x,->", i, VTable[i]);
// FUNC f = (FUNC)VTable[i];
// f();
// }
// cout << endl;
//}
//
//void Test()
//{
// Derive d1;
//
// int *VTable = (int*)(*(int*)&d1);
//
// printVTable(VTable);
//
// //Base2虚函数表在对象Base1后面
// VTable = (int*)(*((int*)&d1+sizeof(Base1)/4));
// printVTable(VTable);
//}
//
//int main()
//{
// Test();
// system("pause");
// return 0;
//}




//多态
//分为静态多态和动态多态
//1，静态多态就是重载，编译期决议
//2，动态多态就是通过继承重写基类的虚函数实现多态，运行时决议
//#include<iostream>
//#include<stdlib.h>
//#include<stdio.h>
//
//using namespace std;
//
//class Base
//{
//public:
// virtual void func1()
// {
// cout << "Base1::func1" << endl;
// }
// virtual void func2()
// {
// cout << "Base1::func2" << endl;
// }
// void display()
// {
// cout << "display()" << endl;
// }
// void display(int i)//重载
// {
// cout << "display(int i)->" << i << endl;
// }
//private:
// int a;
//};
//
//class Derive :public Base
//{
//public:
// virtual void func1()//重写1
// {
// cout << "Derive::func1" << endl;
// }
// virtual void func3()
// {
// cout << "Derive::func3" << endl;
// }
// virtual void func4()
// {
// cout << "Derive::func4" << endl;
// }
//private:
// int b;
//};
//
//void func(Base&b)
//{
// b.func1();
// b.func2();
// b.display();
// b.display(10);
//}
//
//void Test()
//{
// Base b1;
// Derive d1;
// func(b1);
// func(d1);
//}
//
//int main()
//{
// Test();
// system("pause");
// return 0;
//}


//模板
//泛型编程：编写与类型无关的逻辑代码


//模板函数
//比较两个数是否相等
//#include<iostream>
//#include<stdlib.h>
//using namespace std;
//bool IsEqual(int left, int right)
//{
// return left == right;
//}
//bool IsEqual(const string& left, const string&  right)//重载
//{
// return left == right;
//}
//
//void Test()
//{
// string s1("qingdou");
// string s2("range");
// cout << IsEqual(s1, s2) << endl;
// cout << IsEqual(1, 1) << endl;
//}
//int main()
//{
// Test();
// system("pause");
// return 0;
//}




//模板格式
//template<class T1,class T2,class Tn>//或者typename
//#include<iostream>
//#include<stdlib.h>
//using namespace std;
//template<typename T>
//bool IsEqual(const T& left, const T&  right)//重载
//{
// return left == right;
//}
void Test1()
{
string s1("qingdou");
string s2("range");
cout << IsEqual(s1, s2) << endl;
cout << IsEqual(1, 1) << endl;
}
//void Test2()
//{
// string s1("qingdou");
// string s2("range");
// cout << IsEqual(s1, s2) << endl;
// cout << IsEqual(1, 1) << endl;
//
// cout << endl;
//
// cout << IsEqual<int>(1, 1.2) << endl;
// cout << IsEqual<double>(1, 1.2) << endl;
//}
//int main()
//{
// //Test1();
// Test2();
// system("pause");
// return 0;
//}




//重载函数模板
//#include<iostream>
//#include<stdlib.h>
//using namespace std;
//
//bool IsEqual(const int& left, const int&  right)//重载
//{
// return left == right;
//}
//template<typename T>
//bool IsEqual(const T& left, const T&  right)//重载
//{
// return left == right;
//}
//template<typename T1, typename T2 >
//bool IsEqual(const T1& left, const T2&  right)//重载
//{
// return left == right;
//}
//void Test1()
//{
// string s1("qingdou");
// string s2("range");
// cout << IsEqual(s1, s2) << endl;
// cout << IsEqual(1, 1) << endl;
//
// cout << endl;
//
// cout << IsEqual<int>(1, 1) << endl;
// cout << IsEqual(1, 1.2) << endl;
//}
//int main()
//{
// Test1();
// system("pause");
// return 0;
//}




普通类顺序表的定义
//typedef int DataType;
//class SeqList
//{
//private:
// DataType *_data;
// int _size;
// int _capacity;
//};
//template<typename T>
//class SeqList
//{
//private:
// T*_data;
// int _size;
// int _capacity;
//};




//模板类顺序表的定义
//动态顺序表
//#include<iostream>
//#include<stdlib.h>
//using namespace std;
//
//template<typename T>
//class SeqList
//{
//public:
// SeqList();
// ~SeqList();
//private:
// T*_data;
// int _size;
// int _capacity;
//};
//
//template<typename T>
//SeqList<T>::SeqList()
//     : _size(0)
//     , _capacity(10)
//     , _data(new T[_capacity])
//{}
//
//template<typename T>
//SeqList<T>::~SeqList()
//{
// delete[]_data;
//}
//void Test()
//{
// SeqList<int> sl1;
// SeqList<double> sl2;
//}
//int main()
//{
// Test();
// system("pause");
// return 0;
//}




模板参数实现容器的适配器
//#include<iostream>
//#include<stdlib.h>
//using namespace std;
//
//template<typename T>
//class SeqList
//{
//private:
// T*_data;
// int _size;
// int _capacity;
//};
//
//template<class T,template <class>class Container = SeqList>//缺省参数
//class Stack
//{
//public:
// void Push(const T&x);
// void Pop();
// const T& Top();
// bool Empty();
//
//private:
// Container<T> _con;
//};
//
//void Test()
//{
// Stack<int> sl1;
// Stack<int,SeqList> sl2;
//}
//int main()
//{
// Test();
// system("pause");
// return 0;
//}




//非类型的类模板参数
//静态顺序表
//#include<iostream>
//#include<stdlib.h>
//using namespace std;
//
//template<typename T,size_t MAX_SIZE=10>//带缺省模板参数
//class SeqList
//{
//public:
// SeqList();
//private:
// T _arr[MAX_SIZE];
// int _size;
//};
//template<typename T, size_t MAX_SIZE>
//SeqList<T, MAX_SIZE>::SeqList()
//:_size(0)
//{}
//void Test()
//{
// SeqList<int> sl1;
// SeqList<int, 20>sl2;
//}
//int main()
//{
// Test();
// system("pause");
// return 0;
//}




//类模板的特化
全特化
//#include<iostream>
//#include<stdlib.h>
//using namespace std;
//
//template<typename T>
//class SeqList
//{
//public:
// SeqList();
// ~SeqList();
//private:
// int _capacity;
// int _size;
// T* _data;
//};
//template<typename T>
//SeqList<T>::SeqList()
//:_size(0)
//, _capacity(10)
//, _data(new T[_capacity])
//{
// cout << "SeqList<T>" << endl;
//}
//template<typename T>
//SeqList<T>::~SeqList()
//{
// delete[]_data;
//}
//template<>//特化
//class SeqList<int>
//{
//public:
// SeqList(int capacity);
// ~SeqList();
//private:
// int _capacity;
// int _size;
// int* _data;
//};
特化后定义成员函数不再需要模板形参
//SeqList<int>::SeqList(int capacity)
//:_size(0)
//, _capacity(capacity)
//, _data(new int[_capacity])
//{
// cout << "SeqList<int>" << endl;
//}
特化后定义成员函数不再需要模板形参
//SeqList<int>::~SeqList()
//{
// delete[]_data;
//}
//void Test()
//{
// SeqList<double> sl1;
// SeqList<int>sl2(2);
//}
//int main()
//{
// Test();
// system("pause");
// return 0;
//}




//偏特化
#include<iostream>
#include<stdlib.h>
using namespace std;


template<typename T1, typename T2>
class Data
{
public:
Data();
private:
T1 _d1;
T1 _d2;
};
template<typename T1, typename T2>
Data<T1, T2>::Data()
{
cout << "Data<T1, T2>" << endl;
}


//局部特化第二个参数
template<typename T1>
class Data<T1,int>
{
public:
Data();
private:
T1 _d1;
int _d2;
};
template<typename T1>
Data<T1,int>::Data()
{
cout << "Data<T1, int>" << endl;
}


//局部特化两个参数为指针类型
template<typename T1, typename T2>
class Data<T1*, T2*>
{
public:
Data();
private:
T1 _d1;
T2 _d2;
T1* _d3;
T2* _d4;
};
template<typename T1,typename T2>
Data<T1*, T2*>::Data()
{
cout << "Data<T1*, T2*>" << endl;
}


//局部特化两个参数为引用类型
template<typename T1, typename T2>
class Data<T1&, T2&>
{
public:
Data(const T1&d1, const T2&d2);
private:
const T1& _d1;
const T2& _d2;
T1* _d3;
T2* _d4;
};
template<typename T1, typename T2>
Data<T1&, T2&>::Data(const T1&d1, const T2&d2)
:_d1(d1)
, _d2(d2)
{
cout << "Data<T1&, T2&>" << endl;
}
void Test()
{
Data<double, int>d1;
Data<int, double>d2;
Data<int*, int*>d3;
Data<int&, int&>d4(1,2);
}
int main()
{
Test();
system("pause");
return 0;
}


//偏特化并不仅仅是特殊部分参数，而是针对模板参数更进一步的条件限制所涉及出来的一个特化版本
//模板的全特化和偏特化都是在已经定义的模板基础上，不能单独存在
//使用模板在分离编译时容易出错
//应该将声明和定义放在一个文件里(推荐使用)
//在模板头文件.h里面显示实例化->模板类的定义后面添加template class SeqList<int>;(不推荐使用)