33,311
社区成员
发帖
与我相关
我的任务
分享typedef 和 模板 可混用吗？
两个问题。
问题一：
假设有一个模板类
我想定义一个新的类型pA，可是上述代码那样是错误的。正确的应该怎么定义？
问题二：
在 typedef 的百度百科上，代码用法的第5点有三个复杂的类型：
好吧，我完全看不懂
这有void的，有(int,char *)好像形参表之类的东西为什么是类型..乍一看以为是函数
请大神解释。
问题一：
假设有一个模板类
template<class T>
struct A
{
T data;
}
typedef A<T> * pA我想定义一个新的类型pA，可是上述代码那样是错误的。正确的应该怎么定义？
问题二：
在 typedef 的百度百科上，代码用法的第5点有三个复杂的类型：
int *(*a[5])(int, char*);
void (*b[10]) (void (*)());
double(*)() (*pa)[9];好吧，我完全看不懂
这有void的，有(int,char *)好像形参表之类的东西为什么是类型..乍一看以为是函数
请大神解释。
...全文
请发表友善的回复…
发表回复
toofunny 2013-11-29
- 打赏
- 举报
typedef double(* Function)(); //这里定义了一个名为Function的函数指针类型，以double为返回值类型 ，无参数
typedef Function (*FunctionArrayPointer)[9];
//定义一个指向一维数组的指针类型， 该数组的元素类型为Function
int main()
{
Function FunctionArray[1][9] ;//这里定义了Function的二维数组
FunctionArrayPointer pArray = FunctionArray ;
//但FunctionArrayPointer不是一维数组的指针吗？
//答：请仔细复习“行指针”知识，我几句话说不清楚。FunctionArrayPointer是个行指针。
}
还有多远 2013-11-29
- 打赏
- 举报
唉，这种复杂的语法，目前还没见过用在哪个地方过呢，下面是我的理解，抛砖引玉，仅供参考
（1）int *(*a[5])(int, char*)
写成这样应该好理解些:int* (*a[5])(int, char*)
其中左边的int*和右边的(int, char*)共同说明了一个函数类型，即参数类型为int和char*返回类型为int*的函数类型，再看中间的(*a[5])，这个表明它是元素个数为5的数组，所以连起来:
typedef int *(*a[5])(int, char*);
a array;//这里就是定义了一个数组array，这个数组中有5个元素，每一个都是一个函数指针，
//且函数的参数类型为int和char*，返回类型为int*
（2）
void (*b[10]) (void (*)());
与（1）类似，左边的void和右边(void (*)())共同说明了一个函数类型，这种函数无返回值且参数是一个函数指针，这个函数指针指向的函数是一个无返回值且无参数的函数，中间的(*b[10])表示它是一个元素个数为10的数组，所以连起来:
typedef void (*b[10]) (void (*)());
b array;//这里就是定义了一个数组array，这个数组中有10个元素，每一个都是一个函数指针，
//且函数无参数无返回值
注意，这里的void (*)()虽然在C++中理解成上述无参数无返回值的函数指针，但是在C中却可以是带任意参数无返回值的函数指针，且C语言标准保证函数指针解引用时参数的正确接收
（3）double(*)() (*pa)[9]
左边的double(*)()说明了一个函数类型，此函数无参数且返回值为double类型，右边的(*pa)[9]说明它是一个指针，这个指针指向一个含有9个元素的数组，所以连起来：
typedef double (*pFun)();
typedef pFun (*pa)[9];
pa p = NULL;//这里定义了一个指针，它需要指向一个数组，这个数组要含有9个元素，
//且每个元素都是一个函数指针，函数无参数，返回值为double类型
Adol1111 2013-11-29
- 打赏
- 举报
谢谢您的回答。对此我还有些不懂：
1.
[/quote]
问题一：我已经说过了，VS下对C++11更新过慢，所以不一定有这个功能，你看看VS2013有没有这个功能，没有就没办法了。目前gcc下已经除了最小垃圾回收，其他的功能都已经支持了，你可以去试一下。不过具体怎么样用我没做测试，是否这样子我也不太清楚，你可以去查查标准。
问题二，其实这里是有点问题的，我其实想表达的是指向一维的行指针，但是因为一下子找不到这个类型，所以就用其他指针代替了，因为指针的大小都是一样的。至于为什么可以转成9*4byte，你理解可能有问题了。我申请的是第一维的，但这里的9*4是第二维的，这两者无关。
我是认为typedef dfp (*pa)[9]; 已经确定了第二维是 9*4 Byte了，所以只需要申请一维空间就可以了，但后面的高手说是有问题的，属于越界。不过我也觉得只申请一维的话就直接使用二维还是有问题的，最好不要这样使用。看看下面的写法吧。
template<class T>
struct A
{
T data;
}
template<class T>
using pA = A<T> *;
//那么实例化是这样吗？
pA<int> pInt = new A<int>;//这样VS报错
int main()
{
pa a;
a=(pa)malloc(sizeof(dfp));
a[0][0]=f;
a[0][3]=g;
a[0][0]();
a[0][3]();
return 0;
}toofunny 2013-11-29
- 打赏
- 举报
楼主啊，我觉得如果要搞明白这几个例子，你应该攻下这几个难点：
----------------------
指向函数的指针
指针函数的定义
指针函数类型的定义
二维数组与指针的关系（互相转换、地址计算）
行指针
指向指针的指针（定义、使用、与“行指针”的区别（重点））
----------------------
这些东西都不是几句话能说清的，也是相对难理解的。
如果实在不行的话可以先放一放，等以后对语言有了更进一步的理解，再回头看看这些例子。这样复杂的例子在现实中很少会用到。
toofunny 2013-11-28
- 打赏
- 举报
这个代码不错，可惜发生了越界访问。用这句代码即可看出申请到的空间只是4bytes。
cout<<sizeof(dfp)<<endl;
我冒昧修改了一下。
#include<iostream>
using namespace std;
typedef double(* Function)(); //函数类型
typedef Function (*FunctionArrayPointer)[9]; //指向一维数组的指针，数组元素为函数指针
double f(){
cout<<" ff "<<endl;
return double();
}
double g(){
cout<<" gg "<<endl;
return double();
}
int main()
{
Function FunctionArray[1][9] ;
FunctionArrayPointer pArray = FunctionArray ;
pArray[0][0]=f;
pArray[0][1]=g;
pArray[0][0]( );
pArray[0][1]( );
return 0;
}[/quote]
这个是随手写的，因为malloc的时候的确有点意识到不对，不过没细想就贴上来了，实在抱歉。不过刚刚测试了下，的确没有越界。
a=(pa)malloc(sizeof(pa));
cout<<sizeof(a)<<endl;
cout<<sizeof(a[0])<<endl;
MyRe 2013-11-28
- 打赏
- 举报
谢谢您的回答。对此我还有些不懂：
1.
template<class T>
struct A
{
T data;
}
template<class T>
using pA = A<T> *;
//那么实例化是这样吗？
pA<int> pInt = new A<int>;//这样VS报错
int main()
{
pa a;
a=(pa)malloc(sizeof(dfp));
a[0][0]=f;
a[0][3]=g;
a[0][0]();
a[0][3]();
return 0;
}MyRe 2013-11-28
- 打赏
- 举报
这个代码不错，可惜发生了越界访问。用这句代码即可看出申请到的空间只是4bytes。
cout<<sizeof(dfp)<<endl;
我冒昧修改了一下。
#include<iostream>
using namespace std;
typedef double(* Function)(); //函数类型
typedef Function (*FunctionArrayPointer)[9]; //指向一维数组的指针，数组元素为函数指针
double f(){
cout<<" ff "<<endl;
return double();
}
double g(){
cout<<" gg "<<endl;
return double();
}
int main()
{
Function FunctionArray[1][9] ;
FunctionArrayPointer pArray = FunctionArray ;
pArray[0][0]=f;
pArray[0][1]=g;
pArray[0][0]( );
pArray[0][1]( );
return 0;
}[/quote]
typedef double(* Function)(); //这里定义了一个名为Function的函数指针类型，其以double *
//为返回值且以void为参数
typedef Function (*FunctionArrayPointer)[9]; //定义了一个Function指针数组，数组容量为9，类型为
//Function的指针？
int main()
{
Function FunctionArray[1][9] ;//这里定义了Function的二维数组
FunctionArrayPointer pArray = FunctionArray ;//但FunctionArrayPointer不是一维数组的指针吗？
pArray[0][0]=f;
pArray[0][1]=g;
pArray[0][0]( );
pArray[0][1]( );
return 0;
}
ForestDB 2013-11-28
- 打赏
- 举报
从基本的练起。
Adol1111 2013-11-28
- 打赏
- 举报
这个代码不错，可惜发生了越界访问。用这句代码即可看出申请到的空间只是4bytes。
cout<<sizeof(dfp)<<endl;
我冒昧修改了一下。
#include<iostream>
using namespace std;
typedef double(* Function)(); //函数类型
typedef Function (*FunctionArrayPointer)[9]; //指向一维数组的指针，数组元素为函数指针
double f(){
cout<<" ff "<<endl;
return double();
}
double g(){
cout<<" gg "<<endl;
return double();
}
int main()
{
Function FunctionArray[1][9] ;
FunctionArrayPointer pArray = FunctionArray ;
pArray[0][0]=f;
pArray[0][1]=g;
pArray[0][0]( );
pArray[0][1]( );
return 0;
}[/quote]
这个是随手写的，因为malloc的时候的确有点意识到不对，不过没细想就贴上来了，实在抱歉。不过刚刚测试了下，的确没有越界。
a=(pa)malloc(sizeof(pa));
cout<<sizeof(a)<<endl;
cout<<sizeof(a[0])<<endl;toofunny 2013-11-28
- 打赏
- 举报
第三个定义的不是数组，而是一个行指针
toofunny 2013-11-28
- 打赏
- 举报
这个代码不错，可惜发生了越界访问。用这句代码即可看出申请到的空间只是4bytes。
cout<<sizeof(dfp)<<endl;
我冒昧修改了一下。
#include<iostream>
using namespace std;
typedef double(* Function)(); //函数类型
typedef Function (*FunctionArrayPointer)[9]; //指向一维数组的指针，数组元素为函数指针
double f(){
cout<<" ff "<<endl;
return double();
}
double g(){
cout<<" gg "<<endl;
return double();
}
int main()
{
Function FunctionArray[1][9] ;
FunctionArrayPointer pArray = FunctionArray ;
pArray[0][0]=f;
pArray[0][1]=g;
pArray[0][0]( );
pArray[0][1]( );
return 0;
}
Adol1111 2013-11-28
- 打赏
- 举报
这个代码不错，可惜发生了越界访问。用这句代码即可看出申请到的空间只是4bytes。
cout<<sizeof(dfp)<<endl;
我冒昧修改了一下。
#include<iostream>
using namespace std;
typedef double(* Function)(); //函数类型
typedef Function (*FunctionArrayPointer)[9]; //指向一维数组的指针，数组元素为函数指针
double f(){
cout<<" ff "<<endl;
return double();
}
double g(){
cout<<" gg "<<endl;
return double();
}
int main()
{
Function FunctionArray[1][9] ;
FunctionArrayPointer pArray = FunctionArray ;
pArray[0][0]=f;
pArray[0][1]=g;
pArray[0][0]( );
pArray[0][1]( );
return 0;
}[/quote]
这个是随手写的，因为malloc的时候的确有点意识到不对，不过没细想就贴上来了，实在抱歉。不过刚刚测试了下，的确没有越界。
a=(pa)malloc(sizeof(pa));
cout<<sizeof(a)<<endl;
cout<<sizeof(a[0])<<endl;Adol1111 2013-11-28
- 打赏
- 举报
第三个是数组指针，可以看下这个例子（虽然有点糟糕）：
#include<iostream>
#include <vector>
typedef double(* dfp)();
typedef dfp (*pa)[9];
double f(){
cout<<" ff "<<endl;
return 1.1;
}
double g(){
cout<<" gg "<<endl;
return 1.1;
}
int main()
{
pa a;
a=(pa)malloc(sizeof(dfp));
a[0][0]=f;
a[0][3]=g;
a[0][0]();
a[0][3]();
return 0;
}Adol1111 2013-11-28
- 打赏
- 举报
问题一：根据C++11的说法，之前的标准不允许使用typedef给模板取别名，但有些编译器上经常看到类似的效果（应该是编译器自己实现的），新标准中用using给模板取别名。比如：
template <class T>
using My_vec = std::vector<T>;#include<iostream>
#include <vector>
using namespace std;
typedef int *(*a[5])(int, char*);
int * f(int i,char* ch){
cout<<i<<" ff "<<ch<<endl;
int * p = (int*)malloc(sizeof(int));
return p;
}
int * g(int i,char* ch){
cout<<i<<" gg "<<ch<<endl;
int * p = (int*)malloc(sizeof(int));
return p;
}
int main()
{
a p={f,g};
int* p1 = p[0](1,"1");
int* p2 = p[1](2,"2");
return 0;
}
worldy 2013-11-28
- 打赏
- 举报
template<class T> struct A
{ T data; }
typedef A<T> * pA //T应该是具体的类型比如int
int *(*a[5])(int, char*); //函数指针数组，保存的函数类型为返回int*，以int*及 char为参数
void (*b[10]) (void (*)()); //指针数组。函数是以另一个函数指针做参数
double(*)() (*pa)[9]; //这个不懂
