发布时间：2023-07-21 08:30
一：重载-静态绑定
#include
using namespace std;
int maxNum(int a,int b) //int_maxNum_int_int
{
cout<<\"demo1\"<b?a:b;//三目运算符
}
double maxNum(double a,double b) //double_maxNum_double_double
{
cout<<\"demo2\"<b?a:b;//三目运算符
}
int maxNum(double a,int b)
{
cout<<\"demo3\"<b?a:b;//三目运算符
}
int main()
{
//编译时已经确定调用的函数 静态绑定
cout<<\"max:\"< 二：宏定义 不检查数据类型
#include
using namespace std;
#define MAX(a,b)((a)>(b)?(a):(b)) //宏定义 不检查数据类型
int main()
{
cout<<\"max:\"< 小结：
三：模板的学习
a.模板（一种数据类型T）
#include
using namespace std;
template //typename或class都可以 T数据类型
T Max(T a,T b)
{
return a>b?a:b;
}
int main()
{
//函数模板的使用 Max<具体数据类型>(实参);
cout<<\"max:\"<(10,20)< b. 模板（两种数据类型T T1）
#include
using namespace std;
template //T T1两种不同的数据类型
void SWAP(T &a,T1 &b)
{
T tmp;
tmp = a;
a = T(b);
b = T1(tmp);
}
int main()
{
int q=10;
double m = 2.3;
SWAP(q,m);
cout<<\"m=:\"< 小结
函数模板是函数吗？不是函数
格式：template
函数类型 函数名 (形参列表) {函数体}
使用的格式:函数名<实际的数据类型>(实参);
使用的时候编译器会用真正的数据类型来代替函数模板中的参数类型
四：通过类模板实例化一个类 在通过具体类实例化一个对象
1.Test.h
#ifndef TEST_H
#define TEST_H
//类模板声明头文件中 类模板每个成员函数都是函数模板，实现也是在头文件中
template //2种类型数据成员
class TestA
{
public:
TestA();
TestA(T a,T1 b);
T getA();
T1 getB();
private:
T a;
T1 b;
};
template//TestA--类名
TestA::TestA( )
{
this->a = 0;
this->b = 0;
}
template
TestA::TestA(T a,T1 b)
{
this->a = a;
this->b = b;
}
template
T TestA::getA()
{
return this->a;
}
template
T1 TestA::getB()
{
return this->b;
}
#endif
2.main.cpp
#include
using namespace std;
#include\"Test.h\"
int main()
{
//业务逻辑相同 数据类型不同
//通过类模板实例化一个类 在通过具体类实例化一个对象
TestAtest1(100,80.5);
cout<<\"a=\"< 五：模板-创建一条链表
1.CList.h
#ifndef CLIST_H
#define CLIST_H
template//链表的节点模板
class CNode //类名CNode
{
public:
CNode();
~CNode();
T data; // 数据域
CNode *pnext; //指针域
};
template
CNode::CNode()
{
this->data = 0;
this->pnext = NULL;
}
template
CNode::~CNode()
{
}
template
class CList //链表类 类名CList
{
public:
CList();
~CList();
void push_back(T data); //尾部添加节点
int getListCount(); //获取节点个数
private:
CNode* head; //链表头
int count; //节点个数
};
template
CList::CList() //创建头节点
{
this->head = new CNode;
this->count = 0;
}
template
CList::~CList()
{
}
template
void CList::push_back(T data)
{
CNode* tmp = this->head;
while(tmp->pnext!=NULL)
{
tmp = tmp->pnext;
}
CNode* newNode = new CNode;
tmp->pnext = newNode;
newNode->data = data;
++(this->count);
}
template
int CList::getListCount()
{
return this->count;
}
#endif
2.main.cpp
#include
using namespace std;
#include\"Test.h\"
#include\"CList.h\"
int main()
{
//创建一条(int数据类型的)数字链表
CList* head = new CList;
head->push_back(1);
head->push_back(2);
head->push_back(3);
cout<getListCount()< 六：利用上面的链表模板--创建员工链表
1.CStaff.h
#ifndef CSTAFF_H
#define CSTAFF_H
#define ADMIN 1
#define MANAGER 2
#define WAITER 3
class Staff
{
public:
Staff();
Staff(int id,char *name,char *pwd,int prole);
~Staff();
private:
int ID;
char name[20];
char pwd[20];
int role;
};
#endif
2.CStaff.cpp
#include\"CStaff.h\"
#include
using namespace std;
Staff::Staff()
{
}
Staff::Staff(int id,char *name,char *pwd,int prole)
{
this->ID = id;
strcpy(this->name,name);
strcpy(this->pwd,pwd);
this->role = prole;
}
Staff::~Staff()
{
}
3.main.cpp
#include
using namespace std;
#include\"Test.h\"
#include\"CList.h\"
#include\"CStaff.h\"
int main()
{
//创建一条员工链表
CList *staffList = new CList;
staffList->push_back(new Staff(1001,\"admin\",\"123456\",ADMIN));
staffList->push_back(new Staff(1002,\"manager\",\"123456\",MANAGER));
cout<getListCount()< 小结：
类模板：不是类
格式：template
class 类名{ };
类的成员函数全部都是函数模板
使用： 创建对象：类名<真正的数据类型>对象;
对象. + 函数名
七：一般类派生类模板
#ifndef TEST_H
#define TEST_H
//类模板声明头文件中 类模板每个成员函数都是函数模板 实现也是头文件中
// 一般类派生类模板
class A
{
public:
A(){this->z = 0;}
A(int z){this->z = z;}
protected:
int z;
};
template
class TestA;public A //类模板 继承一般类A
{
public:
TestA();
TestA(T a,T1 b,int z);
private:
T a;
T1 b;
};
template //类模板所有成员函数也是模板函数
TestA::TestA():A()
{
this->a = 10;
this->b =10;
}
template
TestA::TestA(T a,T1 b, int z):A(z)
{
this->a = a;
this->b = b;
}
八：从类模板派生出类模板
#ifndef TEST_H
#define TEST_H
//从类模板中派生出类模板
//类模板定义 模板的实现在头文件中
template
class Test
{
public:
Test(void);
~Test();
Test(T a,T1 b);
T getX();
T1 getY();
private:
T x;
T1 y;
};
//---------------基类模板实现---------------
//每个函数都是模板
template
Test::Test(T a,T1 b)
{
this->x= a;
this->y= b;
}
template
Test::Test(void)
{
}
template
Test::~Test(void)
{
}
template
T Test::getX
{
return this->x;
}
template
T1 Test::getY
{
return this->y;
}
//派生类模板定义
template
class TestB:public Test //继承Test
{
public:
TestB(void);
~TestB();
TestB(T a,T1 b,T c);
T getZ();
private:
T z;
};
template
TestB::TestB(T a,T1 b,T c):Test(a,b)
{
this->z =c;
}
template
TestB::TestB(void)
{
}
template
TestB::~TestB(void)
{
}
template
T TestB::getZ()
{
return this->z;
}
#endif
九：普通类 D继承类模板TestA
#ifndef TEST_H
#define TEST_H
//普通类 D继承类模板
class D:public TestA
{
public:
D(){this->d = 0;}
D(int a,float b,int z,int d);
protected:
int d;
private:
};
template
D::D(int a,float b ,int z,int d):TestA(a,b,z)
{
this->d =d;
}
#endif