[已解决]关于typedef定义基础类型问题

理想小青年 · 发表于 2018-6-25 16:32:53

马上注册，结交更多好友，享用更多功能^_^

您需要登录才可以下载或查看，没有账号？立即注册

x

本帖最后由理想小青年于 2018-6-25 16:35 编辑

如图，typedef double ElemType这样来定义，好处我知道（现在看可能理解比较片面），问题如下：
问题：结构体内部定义的元素（ElemType *top），也可以看做 double *top。
那么我在InitStack(sqStack *s),传入结构体指针变量s->base指向一个malloc临时申请空间内存，可是用(ElemType *)用(double *)做结构体申请？这一点学栈没明白！！说以我说typedef学的还是不会......一般不都是引用结构体为申请临时内存体大小，(sqStack *)malloc(sizeof(saStack) * szie)不该这样吗？
1529915188(1).jpg

最佳答案

月排行榜 / 总排行榜

BngThea

2018-6-25 17:25:18

理想小青年发表于 2018-6-25 17:14
后面的呢sizeof(struct)不应该是结构体大小

为什么要是结构体的大小？
等号左边就是一个ElemType的指针而已，分配内存的时候当然只需要分配同类型的即可

跳转到最佳答案楼层

BngThea · 发表于 2018-6-25 16:53:33

前面的(ElemType *)只是一个强制转换的作用

人造人 · 发表于 2018-6-25 17:02:28

C语言复杂声明解析
https://blog.csdn.net/wangweixaut061/article/details/6549768

文章有点长，耐心看完，会对你有帮助的

下面两个程序是一样的，至少在汇编语言层是一样的

#include <stdio.h>
#include <stdlib.h>

#define STACK_INIT_SIZE 100

typedef double ElemType;

typedef struct
{
        ElemType *base;
        ElemType *top;
} sqStack;

void InitStack(sqStack *s)
{
00FBF0E0 55                   push        ebp  
00FBF0E1 8B EC                mov         ebp,esp  
00FBF0E3 81 EC C0 00 00 00    sub         esp,0C0h  
00FBF0E9 53                   push        ebx  
00FBF0EA 56                   push        esi  
00FBF0EB 57                   push        edi  
00FBF0EC 8D BD 40 FF FF FF    lea         edi,[ebp-0C0h]  
00FBF0F2 B9 30 00 00 00       mov         ecx,30h  
00FBF0F7 B8 CC CC CC CC       mov         eax,0CCCCCCCCh  
00FBF0FC F3 AB                rep stos    dword ptr es:[edi]  
        s->base = malloc(STACK_INIT_SIZE * sizeof(ElemType));
00FBF0FE 68 20 03 00 00       push        320h  
00FBF103 E8 12 AD FF FF       call        _malloc (0FB9E1Ah)  
00FBF108 83 C4 04             add         esp,4  
00FBF10B 8B 4D 08             mov         ecx,dword ptr [s]  
00FBF10E 89 01                mov         dword ptr [ecx],eax  
        s->top = s->base;
00FBF110 8B 45 08             mov         eax,dword ptr [s]  
00FBF113 8B 4D 08             mov         ecx,dword ptr [s]  
00FBF116 8B 11                mov         edx,dword ptr [ecx]  
00FBF118 89 50 04             mov         dword ptr [eax+4],edx  
}
00FBF11B 5F                   pop         edi  
00FBF11C 5E                   pop         esi  
00FBF11D 5B                   pop         ebx  
00FBF11E 81 C4 C0 00 00 00    add         esp,0C0h  
00FBF124 3B EC                cmp         ebp,esp  
00FBF126 E8 58 B2 FF FF       call        __RTC_CheckEsp (0FBA383h)  
00FBF12B 8B E5                mov         esp,ebp  
00FBF12D 5D                   pop         ebp  
00FBF12E C3                   ret  
--- 无源文件 -----------------------------------------------------------------------
00FBF12F CC                   int         3  
00FBF130 CC                   int         3  
00FBF131 CC                   int         3  
00FBF132 CC                   int         3  
00FBF133 CC                   int         3  
00FBF134 CC                   int         3  
00FBF135 CC                   int         3  
00FBF136 CC                   int         3  
00FBF137 CC                   int         3  
00FBF138 CC                   int         3  
00FBF139 CC                   int         3  
00FBF13A CC                   int         3  
00FBF13B CC                   int         3  
00FBF13C CC                   int         3  
00FBF13D CC                   int         3  
00FBF13E CC                   int         3  
00FBF13F CC                   int         3  
00FBF140 CC                   int         3  
00FBF141 CC                   int         3  
00FBF142 CC                   int         3  
00FBF143 CC                   int         3  
00FBF144 CC                   int         3  
00FBF145 CC                   int         3  
00FBF146 CC                   int         3  
00FBF147 CC                   int         3  
00FBF148 CC                   int         3  
00FBF149 CC                   int         3  
00FBF14A CC                   int         3  
00FBF14B CC                   int         3  
00FBF14C CC                   int         3  
00FBF14D CC                   int         3  
00FBF14E CC                   int         3  
00FBF14F CC                   int         3  
--- c:\visualstudioprojects\c\c\main.c -----------------------------------------

int main(void)
{
00FBF150 55                   push        ebp  
00FBF151 8B EC                mov         ebp,esp  
00FBF153 81 EC D0 00 00 00    sub         esp,0D0h  
00FBF159 53                   push        ebx  
00FBF15A 56                   push        esi  
00FBF15B 57                   push        edi  
00FBF15C 8D BD 30 FF FF FF    lea         edi,[ebp-0D0h]  
00FBF162 B9 34 00 00 00       mov         ecx,34h  
00FBF167 B8 CC CC CC CC       mov         eax,0CCCCCCCCh  
00FBF16C F3 AB                rep stos    dword ptr es:[edi]  
        sqStack s;
        InitStack(&s);
00FBF16E 8D 45 F4             lea         eax,[s]  
00FBF171 50                   push        eax  
00FBF172 E8 78 C8 FF FF       call        _InitStack (0FBB9EFh)  
00FBF177 83 C4 04             add         esp,4  

        return 0;
00FBF17A 33 C0                xor         eax,eax  
}
00FBF17C 52                   push        edx  
00FBF17D 8B CD                mov         ecx,ebp  
00FBF17F 50                   push        eax  
00FBF180 8D 15 A4 F1 FB 00    lea         edx,ds:[0FBF1A4h]  
00FBF186 E8 B6 C1 FF FF       call        @_RTC_CheckStackVars@8 (0FBB341h)  
00FBF18B 58                   pop         eax  
00FBF18C 5A                   pop         edx  
00FBF18D 5F                   pop         edi  
00FBF18E 5E                   pop         esi  
00FBF18F 5B                   pop         ebx  
00FBF190 81 C4 D0 00 00 00    add         esp,0D0h  
00FBF196 3B EC                cmp         ebp,esp  
00FBF198 E8 E6 B1 FF FF       call        __RTC_CheckEsp (0FBA383h)  
00FBF19D 8B E5                mov         esp,ebp  
00FBF19F 5D                   pop         ebp  
00FBF1A0 C3                   ret

//#include <stdio.h>
//#include <stdlib.h>
//
//#define STACK_INIT_SIZE 100
//
//typedef double ElemType;
//
//typedef struct
//{
//        ElemType *base;
//        ElemType *top;
//} sqStack;
//
//void InitStack(sqStack *s)
//{
//        s->base = malloc(STACK_INIT_SIZE * sizeof(ElemType));
//        s->top = s->base;
//}
//
//int main(void)
//{
//        sqStack s;
//        InitStack(&s);
//
//        return 0;
//}

#include <stdio.h>
#include <stdlib.h>

#define STACK_INIT_SIZE 100

//typedef double ElemType;

typedef struct
{
        double *base;
        double *top;
} sqStack;

void InitStack(sqStack *s)
{
0007F0E0 55                   push        ebp  
0007F0E1 8B EC                mov         ebp,esp  
0007F0E3 81 EC C0 00 00 00    sub         esp,0C0h  
0007F0E9 53                   push        ebx  
0007F0EA 56                   push        esi  
0007F0EB 57                   push        edi  
0007F0EC 8D BD 40 FF FF FF    lea         edi,[ebp-0C0h]  
0007F0F2 B9 30 00 00 00       mov         ecx,30h  
0007F0F7 B8 CC CC CC CC       mov         eax,0CCCCCCCCh  
0007F0FC F3 AB                rep stos    dword ptr es:[edi]  
        s->base = malloc(STACK_INIT_SIZE * sizeof(double));
0007F0FE 68 20 03 00 00       push        320h  
0007F103 E8 12 AD FF FF       call        _malloc (079E1Ah)  
0007F108 83 C4 04             add         esp,4  
0007F10B 8B 4D 08             mov         ecx,dword ptr [s]  
0007F10E 89 01                mov         dword ptr [ecx],eax  
        s->top = s->base;
0007F110 8B 45 08             mov         eax,dword ptr [s]  
0007F113 8B 4D 08             mov         ecx,dword ptr [s]  
0007F116 8B 11                mov         edx,dword ptr [ecx]  
0007F118 89 50 04             mov         dword ptr [eax+4],edx  
}
0007F11B 5F                   pop         edi  
}
0007F11C 5E                   pop         esi  
0007F11D 5B                   pop         ebx  
0007F11E 81 C4 C0 00 00 00    add         esp,0C0h  
0007F124 3B EC                cmp         ebp,esp  
0007F126 E8 58 B2 FF FF       call        __RTC_CheckEsp (07A383h)  
0007F12B 8B E5                mov         esp,ebp  
0007F12D 5D                   pop         ebp  
0007F12E C3                   ret  
--- 无源文件 -----------------------------------------------------------------------
0007F12F CC                   int         3  
0007F130 CC                   int         3  
0007F131 CC                   int         3  
0007F132 CC                   int         3  
0007F133 CC                   int         3  
0007F134 CC                   int         3  
0007F135 CC                   int         3  
0007F136 CC                   int         3  
0007F137 CC                   int         3  
0007F138 CC                   int         3  
0007F139 CC                   int         3  
0007F13A CC                   int         3  
0007F13B CC                   int         3  
0007F13C CC                   int         3  
0007F13D CC                   int         3  
0007F13E CC                   int         3  
0007F13F CC                   int         3  
0007F140 CC                   int         3  
0007F141 CC                   int         3  
0007F142 CC                   int         3  
0007F143 CC                   int         3  
0007F144 CC                   int         3  
0007F145 CC                   int         3  
0007F146 CC                   int         3  
0007F147 CC                   int         3  
0007F148 CC                   int         3  
0007F149 CC                   int         3  
0007F14A CC                   int         3  
0007F14B CC                   int         3  
0007F14C CC                   int         3  
0007F14D CC                   int         3  
0007F14E CC                   int         3  
0007F14F CC                   int         3  
--- c:\visualstudioprojects\c\c\main.c -----------------------------------------

int main(void)
{
0007F150 55                   push        ebp  
0007F151 8B EC                mov         ebp,esp  
0007F153 81 EC D0 00 00 00    sub         esp,0D0h  
0007F159 53                   push        ebx  
0007F15A 56                   push        esi  
0007F15B 57                   push        edi  
0007F15C 8D BD 30 FF FF FF    lea         edi,[ebp-0D0h]  
0007F162 B9 34 00 00 00       mov         ecx,34h  
0007F167 B8 CC CC CC CC       mov         eax,0CCCCCCCCh  
0007F16C F3 AB                rep stos    dword ptr es:[edi]  
        sqStack s;
        InitStack(&s);
0007F16E 8D 45 F4             lea         eax,[s]  
0007F171 50                   push        eax  
0007F172 E8 78 C8 FF FF       call        _InitStack (07B9EFh)  
0007F177 83 C4 04             add         esp,4  

        return 0;
0007F17A 33 C0                xor         eax,eax  
}
0007F17C 52                   push        edx  
0007F17D 8B CD                mov         ecx,ebp  
0007F17F 50                   push        eax  
}
0007F180 8D 15 A4 F1 07 00    lea         edx,ds:[7F1A4h]  
0007F186 E8 B6 C1 FF FF       call        @_RTC_CheckStackVars@8 (07B341h)  
0007F18B 58                   pop         eax  
0007F18C 5A                   pop         edx  
0007F18D 5F                   pop         edi  
0007F18E 5E                   pop         esi  
0007F18F 5B                   pop         ebx  
0007F190 81 C4 D0 00 00 00    add         esp,0D0h  
0007F196 3B EC                cmp         ebp,esp  
0007F198 E8 E6 B1 FF FF       call        __RTC_CheckEsp (07A383h)  
0007F19D 8B E5                mov         esp,ebp  
0007F19F 5D                   pop         ebp  
0007F1A0 C3                   ret

//#include <stdio.h>
//#include <stdlib.h>
//
//#define STACK_INIT_SIZE 100
//
//typedef double ElemType;
//
//typedef struct
//{
//        ElemType *base;
//        ElemType *top;
//} sqStack;
//
//void InitStack(sqStack *s)
//{
//        s->base = malloc(STACK_INIT_SIZE * sizeof(ElemType));
//        s->top = s->base;
//}
//
//int main(void)
//{
//        sqStack s;
//        InitStack(&s);
//
//        return 0;
//}

#include <stdio.h>
#include <stdlib.h>

#define STACK_INIT_SIZE 100

//typedef double ElemType;

typedef struct
{
        double *base;
        double *top;
} sqStack;

void InitStack(sqStack *s)
{
        s->base = malloc(STACK_INIT_SIZE * sizeof(double));
        s->top = s->base;
}

int main(void)
{
        sqStack s;
        InitStack(&s);

        return 0;
}

理想小青年 · 发表于 2018-6-25 17:14:18

BngThea 发表于 2018-6-25 16:53
前面的(ElemType *)只是一个强制转换的作用

后面的呢sizeof(struct)不应该是结构体大小

人造人 · 发表于 2018-6-25 17:21:06

理想小青年发表于 2018-6-25 17:14
后面的呢sizeof(struct)不应该是结构体大小

s->base = malloc(STACK_INIT_SIZE * sizeof(ElemType));
就相当于
s->base = malloc(STACK_INIT_SIZE * sizeof(double));

人造人 · 发表于 2018-6-25 17:23:51

理想小青年发表于 2018-6-25 17:14
后面的呢sizeof(struct)不应该是结构体大小

sizeof(sqStack) 就是两个指针的大小
两个 double 类型的指针的大小

BngThea · 发表于 2018-6-25 17:25:18

这个最佳答案由 BngThea 给出，感谢 BngThea 的回答。

单击隐藏图章

理想小青年发表于 2018-6-25 17:14
后面的呢sizeof(struct)不应该是结构体大小

为什么要是结构体的大小？
等号左边就是一个ElemType的指针而已，分配内存的时候当然只需要分配同类型的即可

理想小青年 · 发表于 2018-6-25 18:57:29

人造人发表于 2018-6-25 17:21
s->base = malloc(STACK_INIT_SIZE * sizeof(ElemType));
就相当于
s->base = malloc(STACK_INIT_SIZE ...

好像一开始学malloc这一块思想就不对

理想小青年 · 发表于 2018-6-25 18:58:54

BngThea 发表于 2018-6-25 17:25
为什么要是结构体的大小？
等号左边就是一个ElemType的指针而已，分配内存的时候当然只需要分配同类型的 ...

一开始学习这块内存管理思想就不对一直以为申请临时内存以结构体大小为申请引子来作
链表那时候也是自己学的理所当然就这样认为了
相同类型即可

人造人 · 发表于 2018-6-25 19:21:06

本帖最后由人造人于 2018-6-25 19:22 编辑

理想小青年发表于 2018-6-25 18:57
好像一开始学malloc这一块思想就不对

void *__cdecl malloc(size_t _Size);
malloc 有一个参数，返回一个指针， void 类型的指针
malloc 从堆中申请 _Size 个字节的内存空间，然后返回这段内存空间的首地址

可以看到 STACK_INIT_SIZE * sizeof(ElemType) 的值是 800，因为 sizeof(ElemType) 的值是 8
也就是从堆中申请 800 个字节的内存空间，至于你要如何用，那是你的事，你完全可以用这段内存空间存储一个字符串 ^_^

你完全可以这么写
char *buf = malloc(800);
因为 STACK_INIT_SIZE * sizeof(ElemType) 的值就是 800

理想小青年 · 发表于 2018-6-26 11:10:54

人造人发表于 2018-6-25 19:21
void *__cdecl malloc(size_t _Size);
malloc 有一个参数，返回一个指针， void 类型的指针
mall ...

我好好看看代码

账号		自动登录	找回密码
密码			立即注册