1,typedef字面意思,自定义一种数据类型
语法:typedef 类型名称 类型标识符;
1),基本用法:
(1) 为基本数据类型定义新的类型名。
(2) 为自定义数据类型(结构体、公用体和枚举类型)定义简洁的类型名称。
(3) 为数组定义简洁的类型名称。
(4) 为指针定义简洁的名称。
简单使用实例:
int main() {
using namespace std;
typedef int hehe;
//相当于定义一个新的数据类型类型
hehe a = 12;
hehe(bb) = 34;
//这两种实现方法是一样的效果,语法而已
printf("%d\n,%d",a,bb);
typedef int f();
//相当于定义一个返回int的函数f
f(daqing);
//等价于声明int daqing(),相当于daqing这个变量也是一个函数名称,实现在main后面
int test = daqing();
printf("test%d",test);
return 0;
}
int daqing() {
return 99;
}
2),typedef结构体语法,并且取别名
using namespace std;
typedef struct node {
int data;
char test;
}tree;
//声明一个结构体struct node的别名为tree
int main() {
tree atree;
atree.data = 1;
//根据结构体的别名初始化变量
node hehe;
hehe.data = 3;
//根据结构的本名初始化变量
return 0;
}
3),typedef声明指针类型
实例1,
using namespace std;
typedef int hehe, hehe2;
//此处可以理解为声明了两种数据类型,一个是hehe类,另一个是hehe2类,两者实际上都是int
typedef int hehe3, *hehe4;
//此处声明了两种数据类型,一种是hehe3类,实际上就是int,另一个是hehe4这个指针数据类型,如果把*hehe4看成一个整体,
//那么这个整体储存的是指向实体的指针,而hehe4是存储的是实体的地址
int main() {
hehe a = 1;
hehe2 b = 2;
//分别创建了a和b作为结构的实体
hehe3 he3 = 3;
//创建了he3为hehe3的结构实体
int aa = 1;
hehe4 bb = &aa;
//创建bb为hehe4这个指针数据类型的结构实体,因为hehe4是一个指针数据类型,所以bb必然也是一个指针,必须按照指针的规则赋值
return 0;
}
实例二,看我typedef一个结构体指针
using namespace std;
typedef struct {
int data;
LNode *next;
}LNode, *LinkList;
//一个上述的struct声明了一种特殊类型LinkList,这个类型表示变量是一个指针
int main() {
LNode hehe;
LinkList daqing = &hehe;
//LinkList数据类型是一个指针数据类型,所以,意思是,声明一个指向LinkList数据类型的指针,然后把已经初始化的LNode类型的变量hehe的地址赋值给这个地址
return 0;
}
2,模板(函数模板)
1),模板简单理解:
首先模板是针对编译器使用的,它就是告诉编译器如何定义函数,比如如下的例子:
template <typename T>
//声明一个模板,第一个参数的固定的,模板名叫T
void Swap(T &a,T &b){
//省略
}
当int变量需要使用Swap的时候,T就变成了int,如果是double变量要使用该函数,T就变成了double,所以说,对计算机来说,计算量丝毫没少。
模板允许只定义一次函数的实现,即可使用不同类型的参数来调用该函数。这样做可以减小代码的书写的复杂度,同时也便于修改。
c++中模板存在的意义:
如果是python,想要交换两个变量的内容:
def exchange(x,y):
a=x;
x=y;
y=a;
return (x,y)
#整数交换
x,y=1,10
x,y=exchange(x,y)
print(x,y)
#字符串交换
x,y="a","bcd"
x,y=exchange(x,y)
print(x,y)
但是如果是c++,这样做明显是不行的,本人菜鸟,写出交换两个整数的代码如下:
void daqing(int *x,int *y);
void daqing(int *x,int *y) {
int a = *x;
*x = *y;
*y = a;
}
int main() {
using namespace std;
int a = 1;
int b = 2;
daqing(&a,&b);
//此处相当于把a,b的地址传递给了daqing函数,而daqing函数拿到的是*&a,*&b,(x和y相当于&a,&b)相当于a和b的值,刚开始*x=1,*y=2,int a 作为局部变量保存了*x的值,1,然后x,y交换。
printf("%d,%d\n",a,b);
return 0;
}
如果想交换两个char或者double,那就得把代码copy一遍,然后把声明和实现的代码中的类型全都变了,好费劲啊,所以这时候我们就需要模板啦。
书上的实例:
#include "pch.h"
using namespace std;
template <typename AnyType>
//电脑电脑,我要建立一个模板,模板名称是AnyType,关键字template和typename是必须的
void Swap(AnyType &a, AnyType&b);
int main() {
int a = 1;
int b = 2;
Swap(a,b);
printf("%d,%d\n",a,b);
double aa = 10;
double bb = 20;
Swap(aa,bb);
printf("%f,%f\n", aa, bb);
string aaa = "12";
string bbb = "abc";
Swap(aaa,bbb);
cout << aaa << " " << bbb << endl;
return 0;
}
template <typename AnyType>
void Swap(AnyType &a, AnyType&b) {
AnyType temp;
temp = a;
a = b;
b = temp;
}
//模板我来理解大约是这么个意思,就是告诉电脑,我要新建一个临时类型,类型名是自己定义的,比如anytype,等到需要用的时候,如果用的是int,那就用int代替anytype,如果是char,就用char代替anytype
注意,函数模板不能缩短可执行程序,我的理解是,swap函数确实生成了int版本的函数,double版本和string版本,并非只有一个函数兼容了不同类型,所以对电脑来说计算量丝毫没有少哦。而模板的好处是,生成多个函数的定义更加可靠,简单。
2),模板不影响重载
//以下生命方法是没问题的,实现省略了,调用swap函数的时候,传入的参数符合哪一个重载函数,就使用哪个
template<typename T>
void Swap(T &a,T &b);
template<typename T>
void Swap(T a[], T b[], int n);
3),显式具体化
个人理解:一个函数模板,可以生成int,double,string等多种不同的具体函数,可以针对某一种特殊的类型进行特殊的操作,比如swap这个模板函数,一般情况下实现a和b的互换,它对job结构进行了显式具体化以后,就可以实现a的某个属性和b的某个属性互换了。嗯嗯
#include <iostream>
using namespace std;
struct job {
char name[10];
double salary;
int floor;
};
template<typename T>
void Swap(T &a,T &b);
//以上是普通声明
template<> void Swap<job>(job &j1, job &j2);
//这是一个显式具体化的声明,意思是:
//不要使用swap模板类生成函数定义,应该使用专门为int类型显示地定义int模板来实现这个函数
void show(job& j);
int main() {
int i, j;
i = 10;
j = 20;
Swap(i,j);
//此处使用隐式实例化,使用模板生成函数定义,模板通过传入的参数i和j判断需要用int,生成了swap的一个int实例
job sue, sidney;
sue = { "sue",73.23,1 };
sidney = { "dsidney",55.23,2 };
Swap(sue, sidney);
//如果swap没有那个重载的显示具体化声明,调用swap以后,sue和sidney会互换,但是sue的工资仍旧是73.23,仍在一楼,sidney也没变,但是
//既然已经有了针对job这个结构专门定义的job模板,所以系统会调用那个显示具体化的swap函数,sue的工资会变成55.23,楼层会变成2楼。
show(sue);
//name is s salary 55.230000 floor 2
return 0;
}
template<typename T>
void Swap(T &a, T &b) {
T temp;
temp = a;
a = b;
b = temp;
}
template<> void Swap<job>(job &j1, job &j2) {
double temp1;
int temp2;
temp1 = j1.salary;
temp2 = j1.floor;
j1.salary = j2.salary;
j1.floor = j2.floor;
j2.salary = temp1;
j2.floor = temp2;
}
void show(job &j){
printf("name is %c salary %lf floor %d", j.name[0], j.salary, j.floor);
//不想用cout,所以打印出来s是sue,d是sidney
}
4),显式实例化
使用某个函数模板的时候,显式地说告诉电脑,我需要一个某类型的模板函数(写为这样:add<double>(aa, bb)。),而不是让电脑根据传入的参数自己判断。
#include <iostream>
using namespace std;
template<typename T>
T add(T a,T b);
//以上是普通声明
int main() {
double result;
int aa = 1;
double bb = 2;
//result = add(aa, bb);
//普通调用add会报错,因为参数aa说T是int,bb说T是个double,然后系统就懵了,
result = add<double>(aa, bb);
//显式地声明add需要使用double生成模板,然后把aa强制转换成double,所以这样跑起来是没问题的
//这就是显式实例化
printf("%lf\n", result);
return 0;
}
template<typename T>
T add(T a, T b) {
return a + b;
}
3,类模板
1),模板基础
普通思想实现一个栈是这样的(本应该头文件和源文件分开,考虑到展示问题,干脆合起来了,请自行分开)
#include "pch.h"
using namespace std;
typedef unsigned long Item;
//定义一个类型,类型名是Item(实际上就是无符号整形),这样写的好处在于,unsigned long如果想变成int,可以直接改动一处。
class Stack
{
private:
enum {MAX=10};
//枚举,此处相当于定义了一个整形MAX变量,
Item items[MAX];
//建立一个数组,数组长度为10,数组以Item类型填充
int top;
public:
Stack();
//构造函数
const bool isEmpty();
const bool isfull();
bool push(const Item &item);
bool pop(Item &item);
//注意,以上都是引用传参,在函数内部修改参数值,不必return外部的参数也会变化
};
int main() {
Stack zhan;
Item a = 100;
Item b = 200;
Item c ;
zhan.push(a);
zhan.push(b);
//添加两个元素到栈里
zhan.pop(c);
//拿出栈顶的元素,元素值用变量c来存储
cout << c << endl;
return 0;
}
Stack::Stack() {
top = 0;
}
const bool Stack::isEmpty() {
return top == 0;
}
const bool Stack::isfull() {
return top == MAX;
}
bool Stack::push(const Item &item) {
if (top < MAX) {
items[top++] = item;
//注意,此处的命令相当于top=top+1;items[top]=item;
cout <<"push command,amount is:"<<top << endl;
return true;
}
else
return false;
}
bool Stack::pop(Item &item) {
if (top>0) {
item = items[--top];
//注意,此处的命令相当于:item=items[top];top=top-1;千万小心别理解错了
cout << "pop command,amount is:" <<top<< endl;
return true;
}
else
return false;
}
使用模板类实现的栈是这样的:
#include "pch.h"
using namespace std;
template <class Type>
//定义一个叫Type的类模板和stack类紧紧关联在一起,甚至分号都不用写了,囧。。。
class Stack
{
private:
enum {MAX=10};
//枚举,此处相当于定义了一个整形MAX变量,
Type items[MAX];
//建立一个数组,数组长度为10,数组以Item类型填充
int top;
public:
Stack();
//构造函数
bool isEmpty();
bool isfull();
bool push(const Type &item);
bool pop(Type &item);
//注意,以上都是引用传参,传递的参数是模板,就是在函数内部修改参数值,不必return外部的参数也会变化
};
int main() {
Stack<int> zhan;
//注意,使用栈实例的时候就不能再写Type这样的模板代号了,要写真正想要实例化的数据类型
int a = 100;
int b = 200;
int c ;
zhan.push(a);
zhan.push(b);
//添加两个元素到栈里
zhan.pop(c);
//拿出栈顶的元素,元素值用变量c来存储
cout << c << endl;
Stack<string> strzhan;
//实例化一个string为模板类型的实例
string aa = "abc";
string bb = "aa0";
string cc;
strzhan.push(aa);
strzhan.push(bb);
//添加两个元素到栈里
strzhan.pop(cc);
//拿出栈顶的元素,元素值用变量c来存储
cout << cc << endl;
typedef double idouble;
Stack<idouble> dbzhan;
//实例化一个自己定义的类型为模板类型的实例,这样竟然也可以,厉害厉害
idouble aaa = 12;
idouble bbb = 234;
idouble ccc;
dbzhan.push(aaa);
dbzhan.push(bbb);
//添加两个元素到栈里
dbzhan.pop(ccc);
//拿出栈顶的元素,元素值用变量c来存储
cout << ccc << endl;
return 0;
}
template <class Type>
Stack<Type>::Stack() {
top = 0;
}
//注意,实现的时候,每个函数都需要加上模板信息,否则报错,语法问题,记住就是了
//注意,普通函数实现的写法是这样的:Stack::Stack(){},但是使用了模板的函数实现的写法是这样的:Stack<Type>::Stack(){},尖括号用于说明,我是一个模板类
template <class Type>
bool Stack<Type>::isEmpty() {
return top == 0;
}
template <class Type>
bool Stack<Type>::isfull() {
return top == MAX;
}
template <class Type>
bool Stack<Type>::push(const Type &item) {
if (top < MAX) {
items[top++] = item;
//注意,此处的命令相当于top=top+1;items[top]=item;
cout <<"push command,amount is:"<<top << endl;
return true;
}
else
return false;
}
template <class Type>
bool Stack<Type>::pop(Type &item) {
if (top>0) {
item = items[--top];
//注意,此处的命令相当于:item=items[top];top=top-1;千万小心别理解错了
cout << "pop command,amount is:" <<top<< endl;
return true;
}
else
return false;
}
2),多个参数的模板
因为模板是编译器对某些特殊字符的替换,所以模板内带的参数也可以是非常具体的数值,比如说,整数5,废话不多说,看例子
#include <stdarg.h>
#include <iostream>
#include <string>
#include <memory> //shared_ptr
#include <vector>
using namespace std;
template<class T, int n>
class Father {
private:
T ar[n];
public:
Father() {};
explicit Father(const T &v);
virtual T &operator[](int i);
//virtual T operator[](int i) const;
};
template<class T, int n>
Father<T, n>::Father(const T &v) {
for (int i = 0; i < n; i++) {
ar[i] = v;
}
}
template<class T, int n>
T &Father<T, n>::operator[](int i) {
if (i<0 || i>n) {
printf("out range");
exit(-1);
}
return ar[i];
};
//template<class T, int n>
//T Father<T, n>::operator[](int i) const {
// if (i<0 || i>n) {
// printf("out range 2nd");
// exit(-1);
// }
// return ar[i];
//}
int main(void)
{
Father<double,5> f1(1.0);
//编译器定义了名为Father<double,5>的一个类,并且创建了该类的对象叫f1,传入了参数1.0
//该实例内部创建了一个长度为5内容都是1.0的double数组
Father<double,6> f2(2.0);
//编译器定义了名为Father<double,6>的一个类,并且创建了该类的对象叫f2,传入了参数2.0
double hehe=f1.operator[](2);
//把f1保存的数组中的数组的第二个元素拿出来看一下,,果然是1.0
//这代码有点傻啊,写个例子还得定义一个重载函数,好吧被我注释掉了,我是书上抄的。
printf("%lf", hehe);
return 0;
}
不过例子归例子,以上这样的写法并不通用,因为模板参数每变一次就生成了新的class,不如 classname<int> instance(12)这样的写法通用