#include<iostream>
using namespace std;class Building{};
class Animal{};
class Cat :public Animal {}; //Cat是Animal的子类//static_cast
//用于内置的数据类型及具有继承关系的指针或者引用
void test01()
{int a = 97;//static_cast<要转换的类型>(转换的数据)char c = static_cast<char>(a);cout << c << endl;//基础数据类型指针 错误/*int* p = NULL;char* sp = static_cast<char*>(p);*///对象指针 错误/*Building* building = NULL;Animal* animal = static_cast<Animal*>(building);*///具有继承关系的对象指针//父类指针转换为子类指针Animal* animal = NULL;Cat* cat = static_cast<Cat*>(animal);//子类指针转换为父类指针Cat* soncat = NULL;Animal* animal_father = static_cast<Animal*>(soncat);//父类引用zhuan子类引用Animal aniobj;Animal& aniref = aniobj;Cat& cat2 = static_cast<Cat&>(aniref);//子类引用转父类引用Cat catobj;Cat& catref = catobj;Animal& anifather2 = static_cast<Animal&>(catref);
}//dynamic_cast
//只能转换具有继承关系的指针或者引用,在转换前会进行对象类型的检测(安全转换)
//只能由子类型转换为父类型
void test02()
{//基础数据类型 错误//int a = 97;/*char c = dynamic_cast<char>(a);*///基础数据类型指针 错误/*int* p = NULL;char* sp = dynamic_cast<char*>(p);*///非继承关系的指针 错误/*Animal* animal = NULL;Building* building = dynamic_cast<Building*>(animal);*///具有继承关系的指针//父类指针转为子类指针 错误//子类转换为父类是安全(从大到小) 父类转换为子类是不安全的(从小到大)/*Animal* ani = NULL; Cat * cat = dynamic_cast<Cat*>(ani); 原因在于dynamic_cast自动做类型安全检测*///子类指针转换为父类指针Cat* cat1 = NULL;Animal* ani = dynamic_cast<Animal*>(cat1);
}//const_cast 取消或者添加变量的const属性后赋值给新值
//针对指针,引用,对象指针
void test03()
{//基础数据类型int a = 10;const int &b = a; //引用 别名//b=20; //错误 int& c = const_cast<int&>(b);c = 20;cout << "a:" << a << endl;cout << "b:" << b << endl;cout << "c:" << c << endl;//指针const int *p = NULL;int* p2=const_cast<int*>(p);int* p3 = NULL;const int* p4 = const_cast<const int*>(p3);
}//reinterpret_cast 强制类型转换
//只转换指针
//任何类型指针都可以转换为其他类型指针(包括函数指针)
typedef void(*FUNC1)(int, int);//申明一个指针变量FUNC1,指向int(*)(int, int)
void add(int a, int b)
{cout << a + b << endl;
}
typedef int(*FUNC2)(int, char*);void test04()
{//1、无关的指针类型都可以进行转换Building* building = NULL;Animal* ani = reinterpret_cast<Animal*>(building);//2.函数指针转换FUNC1 func1=add;//若不用typedef,可以直接func = add (此时,func就是变量,而非变量别名)func1(1, 2);FUNC2 func2 = reinterpret_cast<FUNC2>(func1);
}int main(void)
{test01();test02();test03();test04();system("pause");return 0;
}
运行结果:
二、关于typedef void(*FUNC1)(int, int)的理解
#include "iostream"
using namespace std;
int add(int a,int b){
return (a+b);
}typedef int (* func)(int ,int ) ;
void main(){
func f = add;
int n = f(1,2);
cout << n << endl;
}
在这里的意思是定义一种指针类型func,它是一种指向函数int (int,int)的指针,也就是说func表示的是这种类型的函数的地址,因为:
函数名不是其类型的一部分,函数的类型只由它的返回值和参数表决定.指向add()的指针必须指向与add()相同类型的函数带有相同的返回类型和相同的参数表 。
int (* func)(int ,int )和int* func(int ,int )是不同的,后者说明的是返回一个int类型的指针,所以括号是必须加的
typedef为C语言的关键字,作用是为一种数据类型定义一个新名字。这里的数据类型包括内部数据类型(int,char等)和自定义的数据类型(struct等)。
在编程中使用typedef目的一般有两个
1、一个是给变量一个易记且意义明确的新名字
2、另一个是简化一些比较复杂的类型声明。
用typedef只是对已经存在的类型增加一个类型名,而没有创造一个新的类型。只是增加了一个新名字,可以用该名字定义变量
二.用法
(1)用typedef声明一个新类型名来代替已有的类型名。如:
typedef int Status //指定标识符Status代表int类型 typedef double DATE //指定标识符DATE代表double类型
这样下面代码等价:
int i; double j; Status i;DATE j;
(2)用typedef对数组类型起新名:
typedef int NUM[100];//声明NUM为整数数组类型,可以包含100个元素 NUM n;//定义n为包含100个整数元素的数组,n就是数组名
(3)对一个结构体类型声明一个新名字:
typedef struct //在struct之前用了关键字typedef,表示是声明新类型名 {int month;int day;int year; } TIME; //TIME是新类型名,但不是新类型,也不是结构体变量名
新声明的新类型名TIME代表上面指定的一个结构体类型,这样就可以用TIME定义该结构体变量,如:
TIME birthday; TIME *P //p是指向该结构体类型数据的指针
在typdef可以定义更加复杂的类型,这种情况遇到的不是很多,有时候多层的嵌套会将代码演变的异常复杂,可读性变差。虽然不推荐这么写,但是对于他人写的代码要能理解。关于复杂定义的方式可以阅读参考文献6中的描述:
理解复杂声明可用的“右左法则”:从变量名看起,先往右,再往左,碰到一个圆括号就调转阅读的方向;括号内分析完就跳出括号,还是按先右后左的顺序,如此循环,直到整个声明分析完。举例:
int (*func)(int *p)
首先找到变量名func,外面有一对圆括号,而且左边是一个*号,这说明func是一个指针;然后跳出这个圆括号,先看右边,又遇到圆括号,这说明(*func)是一个函数,所以func是一个指向这类函数的指针,即函数指针,这类函数具有int*类型的形参,返回值类型是int。
int (*func[5])(int *)
func右边是一个[]运算符,说明func是具有5个元素的数组;func的左边有一个*,说明func的元素是指针(注意这里的*不是修饰func,而是修饰func[5]的,原因是[]运算符优先级比*高,func先跟[]结合)。跳出这个括号,看右边,又遇到圆括号,说明func数组的元素是函数类型的指针,它指向的函数具有int*类型的形参,返回值类型为int。
2. 隐藏技能
typedef 定义的新类型, 使用时可以省略括号.
typedef int NUM;
NUM a = 10; // 也可写成`NUM(a) = 10;
NUM(b) = 12; // 也可写成`NUM b = 12;
整形:
typedef int x; // 定义了一个名为x的int类型
结构体:
typedef struct { char c; } s; // 定义名为s的struct类型
指针
typedef int *p; //定义了一个名为p的指针类型, 它指向int (中文描述指针好累)
接下来是高级的(注意标识符不一定在最后):
数组
typedef int A[]; // 定义一个名为A的ints数组的类型
函数:
typedef int f(); // 定义一个名为f, 参数为空, 返回值为int的函数类型
typedef int g(int); // 定义一个名为g, 含一个int参数, 返回值为int行的函数类型
typedef int P();
static P(Q);
应该就比较好理解了, P是一个新定义的function类型, 它返回值为int, 无参数
根据我的第2点说明, P(Q); 实际上等价于P Q, 声明Q是一个返回值为int, 无参数的函数.
这玩意有什么用呢?
我们都知道C++语言里, 函数都是先声明后使用的(除非在使用之前定义), 看以下例子:
#include <iostream>
#include <stdio.h>
#include <string>
typedef int P(); // 简单的
typedef void Q(int *p, const std::string& s1, const std::string& s2, size_t size, bool is_true); // 复杂的
class X {
public:P(eat_shit); // 等价于声明`int eat_shit();`Q(bullshit); // 等价于声明`void bullshit(int *p, const string& s1, const string& s2, size_t size, bool is_true);`
};int main() {X *xx;printf("shit ret: %d\n", xx->eat_shit());int a[] = {1, 3, 4, 5, 7};xx->bullshit(a, "foo", "bar", sizeof(a)/sizeof(int), true);
}
int X::eat_shit() {return 888;
}void X::bullshit(int *p, const std::string& s1, const std::string& s2, size_t size, bool is_true) {std::cout << "s1: " << s1 << ", s2: " << s2 << ", size: " << size << std::endl;printf("elems:\n");for(int i = 0; i < size; i++) {printf("%d %s", *p++, (i == size-1) ? "" : ",");}printf("\n");
}
在阅读Linux的内核代码是经常会遇到一些复杂的声明和定义,例如:
(1) void * (* (*fp1) (int)) [10];
(2) float (* (*fp2) (int, int, float)) (int);
(3) typedef double (* (* (*fp3) ()) [10]) ();
fp3 a;
(4) int (* (*fp4()) [10]) ();
刚看到这些声明或者定义时,一些初学者甚至有一定经验的工程师都有可能头皮发毛,基于大惑不解。如果缺乏经验和方法来对这些内容进行理解,势必会让我们浪费大量的时间。
我尝试对这些内容进行疏理和总结,为自己和有同样困惑的同学答疑解惑。要理解这些复杂的声明和定义,我觉得首先不能着急,应该由浅而深,逐步突破。下面先看一些简单的定义:
1. 定义一个整型数
int a;
2. 定义一个指向整型数的指针
int *p;
3. 定义一个指向指针的指针,它指向的指针指向一个整型数
int **pp;
到这一步我想大多数人都还好理解,我们可以用一些简单的代码把这三条给串起来:
在阅读Linux的内核代码是经常会遇到一些复杂的声明和定义,例如:
(1) void * (* (*fp1) (int)) [10];
(2) float (* (*fp2) (int, int, float)) (int);
(3) typedef double (* (* (*fp3) ()) [10]) ();
fp3 a;
(4) int (* (*fp4()) [10]) ();
刚看到这些声明或者定义时,一些初学者甚至有一定经验的工程师都有可能头皮发毛,基于大惑不解。如果缺乏经验和方法来对这些内容进行理解,势必会让我们浪费大量的时间。
我尝试对这些内容进行疏理和总结,为自己和有同样困惑的同学答疑解惑。要理解这些复杂的声明和定义,我觉得首先不能着急,应该由浅而深,逐步突破。下面先看一些简单的定义:
1. 定义一个整型数
int a;
2. 定义一个指向整型数的指针
int *p;
3. 定义一个指向指针的指针,它指向的指针指向一个整型数
int **pp;
到这一步我想大多数人都还好理解,我们可以用一些简单的代码把这三条给串起来:
在阅读Linux的内核代码是经常会遇到一些复杂的声明和定义,例如:
(1) void * (* (*fp1) (int)) [10];
(2) float (* (*fp2) (int, int, float)) (int);
(3) typedef double (* (* (*fp3) ()) [10]) ();
fp3 a;
(4) int (* (*fp4()) [10]) ();
刚看到这些声明或者定义时,一些初学者甚至有一定经验的工程师都有可能头皮发毛,基于大惑不解。如果缺乏经验和方法来对这些内容进行理解,势必会让我们浪费大量的时间。
我尝试对这些内容进行疏理和总结,为自己和有同样困惑的同学答疑解惑。要理解这些复杂的声明和定义,我觉得首先不能着急,应该由浅而深,逐步突破。下面先看一些简单的定义:
1. 定义一个整型数
int a;
2. 定义一个指向整型数的指针
int *p;
3. 定义一个指向指针的指针,它指向的指针指向一个整型数
int **pp;
到这一步我想大多数人都还好理解,我们可以用一些简单的代码把这三条给串起来:
int a;
int *p;
int **pp;
p = &a; // p指向整数a所在的地址
pp = &p; // pp指向指针p
4. 定义一个包含10个整型数的数组
int arr[10];
5. 定义一个指向包含10个整型数数组的指针
int (*pArr) [10];
用几行代码将4、5两个定义串起来:
int arr[10];
int (*pArr) [10];pArr = &arr;
6. 定义一个指向函数的指针,被指向的函数有一个整型参数并返回整型值
int (*pfunc) (int);
7. 定义一个包含10个指针的数组,其中包含的指针指向函数,这些函数有一个整型参数并返回整型值
int (*arr[10]) (int);
用几行代码将6、7两个定义串起来:
int (*pfunc) (int);
int (*arr[10]) (int);arr[0] = pfunc;
到这一步,似乎就不是那么好理解了。现在需要请出用于理解复杂定义的“右左法则”:
从变量名看起,先往右,再往左,碰到圆括号就调转阅读的方向;括号内分析完就跳出括号,还是先右后左的顺序。如此循环,直到分析完整个定义。
让我们用这个方法来分析上面的第6条定义:int (*pfunc) (int);
找到变量名pfunc,先往右是圆括号,调转方向,左边是一个*号,这说明pfunc是一个指针;然后跳出这个圆括号,先看右边,又遇到圆括号,这说明(*pfunc)是一个函数,所以pfunc是一个指向这类函数的指针,即函数指针,这类函数具有一个int类型的参数,返回值类型是int。
接着分析第7条定义:int (*arr[10]) (int);
找到变量名arr,先往右是[]运算符,说明arr是一个数组;再往左是一个*号,说明arr数组的元素是指针(注意:这里的*修饰的不是arr,而是arr[10]。原因是[]运算符的优先级比*要高,arr先与[]结合。);跳出圆括号,先往右又遇到圆括号,说明arr数组的元素是指向函数的指针,它指向的函数有一个int类型的参数,返回值类型是int。
分析完这两个定义,相信多数人心里面应该有点谱了。可应该还有人会问:怎么判断定义的是函数指针(定义6),还是数组指针(定义5),或是数组(定义7)?可以抽象出几个模式:
- type (*var)(...); // 变量名var与*结合,被圆括号括起来,右边是参数列表。表明这是函数指针
- type (*var)[]; //变量名var与*结合,被圆括号括起来,右边是[]运算符。表示这是数组指针
- type (*var[])...; // 变量名var先与[]结合,说明这是一个数组(至于数组包含的是什么,由旁边的修饰决定)
至此,我们应该有能力分析文章开始列出来了几条声明和定义:
(1) void * (* (*fp1) (int)) [10];
找到变量名fp1,往右看是圆括号,调转方向往左看到*号,说明fp1是一个指针;跳出内层圆括号,往右看是参数列表,说明fp1是一个函数指针,接着往左看是*号,说明指向的函数返回值是指针;再跳出外层圆括号,往右看是[]运算符,说明函数返回的是一个数组指针,往左看是void *,说明数组包含的类型是void *。简言之,fp1是一个指向函数的指针,该函数接受一个整型参数并返回一个指向含有10个void指针数组的指针。
(2) float (* (*fp2) (int, int, float)) (int);
找到变量名fp2,往右看是圆括号,调转方向往左看到*号,说明fp2是一个指针;跳出内层圆括号,往右看是参数列表,说明fp2是一个函数指针,接着往左看是*号,说明指向的函数返回值是指针;再跳出外层圆括号,往右看还是参数列表,说明返回的指针是一个函数指针,该函数有一个int类型的参数,返回值类型是float。简言之,fp2是一个指向函数的指针,该函数接受三个参数(int, int和float),且返回一个指向函数的指针,该函数接受一个整型参数并返回一个float。
(3) typedef double (* (* (*fp3) ()) [10]) ();
fp3 a;
如果创建许多复杂的定义,可以使用typedef。这一条显示typedef是如何缩短复杂的定义的。
跟前面一样,先找到变量名fp3(这里fp3其实是新类型名),往右看是圆括号,调转方向往左是*,说明fp3是一个指针;跳出圆括号,往右看是空参数列表,说明fp3是一个函数指针,接着往左是*号,说明该函数的返回值是一个指针;跳出第二层圆括号,往右是[]运算符,说明函数的返回值是一个数组指针,接着往左是*号,说明数组中包含的是指针;跳出第三层圆括号,往右是参数列表,说明数组中包含的是函数指针,这些函数没有参数,返回值类型是double。简言之,fp3是一个指向函数的指针,该函数无参数,且返回一个含有10个指向函数指针的数组的指针,这些函数不接受参数且返回double值。
这二行接着说明:a是fp3类型中的一个。
(4) int (* (*fp4()) [10]) ();
这里fp4不是变量定义,而是一个函数声明。
找到变量名fp4,往右是一个无参参数列表,说明fp4是一个函数,接着往左是*号,说明函数返回值是一个指针;跳出里层圆括号,往右是[]运算符,说明fp4的函数返回值是一个指向数组的指针,往左是*号,说明数组中包含的元素是指针;跳出外层圆括号,往右是一个无参参数列表,说明数组中包含的元素是函数指针,这些函数没有参数,返回值的类型是int。简言之,fp4是一个返回指针的函数,该指针指向含有10个函数指针的数组,这些函数不接受参数且返回整型值。
以上我们已经看到了不少复杂的声明和定义,这里再举一个例子:
int *(*a[10]) (int, char*);
用前面的“右左法则”,我们可以很快弄清楚:a是一个包含10个函数指针的数组,这些函数的参数列表是(int, char*),返回值类型是int*。理解已经不成问题,这里的关键是如果要定义相同类型的变量b,都得重复书写:
int *(*b[10]) (int, char*);
这里有没有方便的办法避免这样没有价值的重复?答案就是用typedef来简化复杂的声明和定义。
typedef可以给现有的类型起个别名。这里用typedef给以上a、b的类型起个别名:
typedef int *(*A[10]) (int, char*); // 在之前定义的前面加入typedef,然后将变量名a替换成类型名A
现在要再定义相同类型的变量c,只需要:
A c;
再看一例:
void (*b[10]) (void (*)());
先替换右边括号里面的参数,将void (*)()的类型起个别名pParam:
typedef void (*pParam) ();
再替换左边的变量b,为b的类型起个别名B:
typedef void (*B) (pParam);
原声明的简化版:
B b[10];
#include<stdio.h>
int inc(int a)
{return(++a);
}int multi(int*a, int*b, int*c)
{return(*c = *a**b);
}typedef int(FUNC1)(int); //申明一个指针变量FUNC1,指向int(int)
typedef int(FUNC2)(int*, int*, int*);void show(FUNC2 fun, int arg1, int *arg2)
{//fun 为指向函数int multi(int*a,int*b,int*c)的指针//arg1 = 10,arg2 =&a;FUNC1 *p = &inc; //p为指向函数inc的指针int temp = p(arg1); //等价于 temp = inc(arg1) = inc(10) = 11fun(&temp, &arg1, arg2);//运行fun()函数后,*arg2 = temp * arg1 = 11 * 10 = 110printf("%d\n", *arg2);
}
int main()
{int a;show(multi, 10, &a);return 0;
}
结果为110
参考自https://blog.csdn.net/hai008007/article/details/80651886
https://blog.csdn.net/baoendemao/article/details/41209697