皮皮网

1.C/C++ typedef用法详解
2.C++ typedef & typename知识点总结
3.用C语言写的计算器源代码
4.typedef和define具体的详细区别

C/C++ typedef用法详解

       typedef在C/C++中的四个核心用途:

       一、作为别名，简化代码编写，如在大量使用指针时，typedef能让声明更直观。

       二、本地授权源码在旧C代码中，typedef可以简化struct的使用，如从`struct 结构名 对象名`到`结构名 对象名`。

       三、定义平台无关的类型，如REAL类型的浮点类型，根据目标平台调整类型。

       四、为复杂声明提供简化别名，如将`int(*a[5])(int, char)`简化为`pFun a[5]`。

       然而，typedef也有两大陷阱需要注意:

       typedef不是简单的字符串替换，如`const PSTR`不等于`const char*`，而是`char* const`。

       typedef不能与其他存储类关键字一起使用，控盘源码贴图如`typedef static int INT2`是无效的。

       与#define相比，typedef在指针场景下更具优势，能避免一些常见问题。同时，typedef也常用于抑制不良代码，提升代码质量。

       例如，typedef有助于创建平台无关的类型，比如在不同平台上定义REAL类型，庄筹线源码仅需更改typedef定义，无需修改源代码。

C++ typedef & typename知识点总结

       用过 C++ 的同学对 typename 和 typedef 相信并不是很陌生，但是当我看到下面这段代码的时候仍然无法理解：

       按理来说 typedef 一般不是用来定义一种类型的别名，如下：

       定义了一个 int 的别名是 SpeedType，那么我就可以这样用：

       但是 typedef 后面接 typename 表示什么意思呢？typename 不是用来定义模板参数的吗？下面我们分别归纳一下 typedef & typename 的用法。

       首先来看看 typedef 的几种常见用法。

       为特定含义的类型取别名

       这个我在上面已经讲过了，但是它是定义一种类型的别名，而不只是显卡占用显示源码简单的宏替换，也可以用作同时声明指针型的多个对象的。

       比如：

       本来想要把 pa、pb 两个变量都声明为字符串，但是这样只能成功声明了一个。但是我们使用 typedef 就可以成功声明两个：

       为结构体取别名

       在声明变量的时候，需要带上 struct，即像下面这样使用：

       用来定义与平台无关的类型

       比如定义一个叫 REAL 的浮点类型，在目标平台一上，让它表示最高精度的类型为：

       在不支持 long double 的平台二上，改为：

       当跨平台时，济南溯源码加工只要改下 typedef 本身就行，不用对其他源码做任何修改。

       typename

       typename 关键字用于引入一个模板参数，这个关键字用于指出模板声明（或定义）中的非独立名称（dependent names）是类型名，而非变量名：

       typename 在这里的意思表明 T 是一个类型。如果没有它的话，在某些情况下会出现模棱两可的情况，比如下面这种情况：

       作者想定义一个指针iter，它指向的类型是包含在类作用域T中的iterator。可能存在这样一个包含iterator类型的结构：

       那么foo(); 这样用的是的时候确实可以知道 iter是一个ContainsAType::iterator类型的指针。但是T::iterator实际上可以是以下三种中的任何一种类型：

       所以如果是下面这样的情况：

       那T::iterator * iter;被编译器实例化为ContainsAnotherType::iterator * iter;，变成了一个静态数据成员乘以 iter ，这样编译器会找不到另一个变量 iter 的定义 。所以为了避免这样的歧义，我们加上 typename，表示 T::iterator 一定要是个类型才行。

       得出结论

       我们回到一开始的例子，对于vector::size_type，我们可以知道：

       vector::size_type是vector的嵌套类型定义，其实际等价于 size_t类型。

       那么这个例子的真是面目是，typedef创建了存在类型的别名，而typename告诉编译器std::vector::size_type是一个类型而不是一个成员。

       加一个例子

       好了，看了上面的例子你应该已经完全懂 typedef & typename 的精髓了，我们下面来讲解一个例子，用模板实现类似下面的循环：

       首先我们需要一个循环模板：

       这里应该可以看的懂，这几个模板，无论是 res_type 还是 type 都用 typename 修饰，表明都是类型，然后再接上 typedef 表示给这个类型定义了一个别名。

       再定义循环模板的时候，有一个约定，它必须提供一个静态数据成员，cond_value，及两个子类型定义，res_type 和 next_type：

       WhileLoop 用特化来决定走递归分支还是退出循环分支。

       然后我们定义一个模板代表数值：

       通过 value 可以获取到对应的数值，value_type 则是这个数值的类型。

       通过上面的模板可以实现While<>::type>::type::value 1 加到 的结果。实际上就是通过类型的循环展开实现了 1 加到 运算结果。

用C语言写的计算器源代码

       #include<stdio.h>

       #include<iostream.h>

       #include<stdlib.h>

       #include<string.h>

       #include<ctype.h>

       typedef float DataType;

       typedef struct

       {

        DataType *data;

        int max;

        int top;

       }Stack;

       void SetStack(Stack *S,int n)

       {

        S->data=(DataType*)malloc(n*sizeof(DataType));

        if(S->data==NULL)

        {

        printf("overflow");

        exit(1);

        }

        S->max=n;

        S->top=-1;

       }

       void FreeStack(Stack *S)

       {

        free(S->data);

       }

       int StackEmpty(Stack *S)

       {

        if(S->top==-1)

        return(1);

        return(0);

       }

       DataType Peek(Stack *S)

       {

        if(S->top==S->max-1)

        {

        printf("Stack is empty!\n");

        exit(1);

        }

        return(S->data[S->top]);

       }

       void Push(Stack *S,DataType item)

       {

        if(S->top==S->max-1)

        {

        printf("Stack is full!\n");

        exit(1);

        }

        S->top++;

        S->data[S->top]=item;

       }

       DataType Pop(Stack *S)

       {

        if(S->top==-1)

        {

        printf("Pop an empty stack!\n");

        exit(1);

        }

        S->top--;

        return(S->data[S->top+1]);

       }

       typedef struct

       {

        char op;

        int inputprecedence;

        int stackprecedence;

       }DataType1;

       typedef struct

       {

        DataType1 *data;

        int max;

        int top;

       }Stack1;

       void SetStack1(Stack1 *S,int n)

       {

        S->data=(DataType1*)malloc(n*sizeof(DataType1));

        if(S->data==NULL)

        {

        printf("overflow");

        exit(1);

        }

        S->max=n;

        S->top=-1;

       }

       void FreeStack1(Stack1 *S)

       {

        free(S->data);

       }

       int StackEmpty1(Stack1 *S)

       {

        if(S->top==-1)

        return(1);

        return(0);

       }

       DataType1 Peek1(Stack1 *S)

       {

        if(S->top==S->max-1)

        {

        printf("Stack1 is empty!\n");

        exit(1);

        }

        return(S->data[S->top]);

       }

       void Push1(Stack1 *S,DataType1 item)

       {

        if(S->top==S->max-1)

        {

        printf("Stack is full!\n");

        exit(1);

        }

        S->top++;

        S->data[S->top]=item;

       }

       DataType1 Pop1(Stack1 *S)

       {

        if(S->top==-1)

        {

        printf("Pop an empty stack!\n");

        exit(1);

        }

        S->top--;

        return(S->data[S->top+1]);

       }

       DataType1 MathOptr(char ch)

       {

        DataType1 optr;

        optr.op=ch;

        switch(optr.op)

        {

        case'+':

        case'-':

        optr.inputprecedence=1;

        optr.stackprecedence=1;

        break;

        case'*':

        case'/':

        optr.inputprecedence=2;

        optr.stackprecedence=2;

        break;

        case'(':

        optr.inputprecedence=3;

        optr.stackprecedence=-1;

        break;

        case')':

        optr.inputprecedence=0;

        optr.stackprecedence=0;

        break;

        }

        return(optr);

       }

       void Evaluate(Stack *OpndStack,DataType1 optr)

       {

        DataType opnd1,opnd2;

        opnd1=Pop(OpndStack);

        opnd2=Pop(OpndStack);

        switch(optr.op)

        {

        case'+':

        Push(OpndStack,opnd2+opnd1);

        break;

        case'-':

        Push(OpndStack,opnd2-opnd1);

        break;

        case'*':

        Push(OpndStack,opnd2*opnd1);

        break;

        case'/':

        Push(OpndStack,opnd2/opnd1);

        break;

        }

       }

       int isoptr(char ch)

       {

        if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='(')

        return(1);

        return(0);

       }

       void Infix(char *str)

       {

        int i,k,n=strlen(str);

        char ch,numstr[];

        DataType opnd;

        DataType1 optr;

        Stack OpndStack;

        Stack1 OptrStack;

        SetStack(&OpndStack,n);

        SetStack1(&OptrStack,n);

        k=0;

        ch=str[k];

        while(ch!='=')

        if(isdigit(ch)||ch=='.')

        {

        for(i=0;isdigit(ch)||ch=='.';i++)

        {

        numstr[i]=ch;

        k++;

        ch=str[k];

        }

        numstr[i]='\0';

        opnd= atof(numstr);

        Push(&OpndStack,opnd);

        }

        else

        if(isoptr(ch))

        {

        optr=MathOptr(ch);

        while(Peek1(&OptrStack).stackprecedence>=optr.inputprecedence)

        Evaluate(&OpndStack,Pop1(&OptrStack));

        Push1(&OptrStack,optr);

        k++;

        ch=str[k];

        }

        else if(ch==')')

        {

        optr=MathOptr(ch);

        while(Peek1(&OptrStack).stackprecedence>=optr.inputprecedence)

        Evaluate(&OpndStack,Pop1(&OptrStack));

        Pop1(&OptrStack);

        k++;

        ch=str[k];

        }

        while(!StackEmpty1(&OptrStack))

        Evaluate(&OpndStack,Pop1(&OptrStack));

        opnd=Pop(&OpndStack);

        cout<<"你输入表达式的计算结果为"<<endl;

        printf("%-6.2f\n",opnd);

        FreeStack(&OpndStack);

        FreeStack1(&OptrStack);

       }

       void main()

       {

        cout<<"请输入你要计算的表达式,并以“=”号结束。"<<endl;

        char str[];

        gets(str);

        Infix(str);

       =================================================================

       哈哈！给分吧！

typedef和define具体的详细区别

       #define是编译预处理指令，在编译预处理时换，不作正确性检查，不论是否正确只进行带入替换，只有在编译已被展开的源程序时才会发现可能的错误并报错。

       2.typedef为C语言的关键字，作用是为一种数据类型定义一个新名字。

       ä¸¤è€…的区别如例：

       #define A int *         tepedef int * A；（这是一条语句，要加分号）

       ä¸¤è€…的作用都是将A代表int *，但是#define在预处理时进行简单的替换，而typedef不是简单替换。

       typedef定义的A相当于定义了一个指针指向了int *。而#define定义的A只是进行了替换。

扩展资料：

       typedef 有另外一个重要的用途，那就是定义机器无关的类型，例如，你可以定义一个叫 REAL 的浮点类型，在目标机器上它可以获得最高的精度：

       typedef long double REAL;

       åœ¨ä¸æ”¯æŒ long double 的机器上，该 typedef 看起来会是下面这样：

       typedef double REAL;

       å¹¶ä¸”，在连 double 都不支持的机器上，该 typedef 看起来会是这样：

       typedef float REAL;

       ä½ ä¸ç”¨å¯¹æºä»£ç åšä»»ä½•ä¿®æ”¹ï¼Œä¾¿å¯ä»¥åœ¨æ¯ä¸€ç§å¹³å°ä¸Šç¼–译这个使用 REAL 类型的应用程序。唯一要改的是 typedef 本身。在大多数情况下，甚至这个微小的变动完全都可以通过奇妙的条件编译来自动实现。不是吗? 标准库广泛地使用 typedef 来创建这样的平台无关类型：size_t，ptrdiff

        和 fpos_t 就是其中的例子。此外，象 std::string 和 std::ofstream 这样的 typedef

       è¿˜éšè—äº†é•¿é•¿çš„，难以理解的模板特化语法，例如：basic_string，allocator> 和 basic_ofstream>。

参考资料：typedef-百度百科