C programming coding 问题

莲花

我run不到，有谁可以帮我看哪里出错？




#include <stdio.h>
#include <stdlib.h>
#include<math.h>
#include<ctype.h>
#include<string.h>

struct stackNode {
    int data;
    struct stackNode *nextPtr;
};
typedef struct stackNode StackNode;
typedef StackNode *StackNodePtr;

int evaluatePostfixExpression( char *expr );
int calculate( int op1, int op2, char Operator );
void push( StackNodePtr *topPtr, int value );
int pop( StackNodePtr *topPtr );
int isEmpty( StackNodePtr topPtr );
void printStack( StackNodePtr topPtr );

char postfix[50];
int answer;



void main()
{
    printf("Print an postfix expression\n");
    scanf("%s", postfix);
    evaluatePostfixExpression(postfix);
    printf("The value of the expression is: %i",answer);
}

int evaluatePostfixExpression( char *expr )
    //Evaluate the postfix expression.
{

    StackNode node;
    StackNodePtr ptrnode;
    ptrnode = &node;

    int x;
    int y;
    int z;

    strcat( expr , '\0' );/*Append the null character ('\0') to the end of the postfix expression.
    When the null character is encountered, no further processing is necessary.*/

    int i=0;
    for(i; postfix[i]!='\0'; i++){      //While '\0' has not been encountered, read the expression from left to right.
        if(isdigit(postfix[i])){           //If the current character is a digit,Push its integer value onto the stack
            push(&ptrnode, postfix[i]); //(the integer value of a digit character is its value in the computer's character
            printStack(ptrnode);                           //set minus the value of '0' in the computer's character set).
        }
        else if(postfix[i]=='+'||postfix[i]=='-'||postfix[i]=='*'||postfix[i]=='/'||postfix[i]=='^'){                   //Otherwise, if the current character is an operator, Pop the two top elements of the stack into
            x=pop(&ptrnode);    //variables x and y. Calculate y operator x.
            printStack(ptrnode);
            y=pop(&ptrnode);
            printStack(ptrnode);
            z=calculate(x,y,postfix[i]);
            push(&ptrnode, z);          /*Push the result of the calculation onto the stack.*/
            printStack(ptrnode);
        }
        if (postfix[i]=='\0'){  //When the null character is encountered in the expression, pop the top value of the
            answer = pop(&ptrnode);//stack. This is the result of the postfix expression.
            printStack(ptrnode);
        }

        }
}

int calculate( int op1, int op2, char Operator )
    //Evaluate the expression op1 operator op2.
{
    if (Operator=='+')
        return op1+op2;

    else if (Operator=='-')
        return op1-op2;

    else if (Operator=='*')
        return op1*op2;

    else if (Operator=='/')
        return op1/op2;

    else if (Operator=='^')
        return op1^op2;



    else{
    return printf("calculation error");
    }
}

void push( StackNodePtr *topPtr, int value )
    //Push a value on the stack.
{
    StackNodePtr temp; /* to create a new node */
    temp = (StackNodePtr) malloc(sizeof(value));//need Malloc because it will not remember it
    temp->data = value;
    temp->nextPtr = NULL; /* the new node points to NULL */


    if(isEmpty(*topPtr)==0) {
    temp->nextPtr = *topPtr;
    }

}

int pop( StackNodePtr *topPtr )
    //Pop a value off the stack.
{
    char Data ; /* to be used to store the data */
    StackNodePtr tmp; /* to be used for handling the node*/
                        /* that is going to be deleted */
    tmp = *topPtr; /* tmp has the address of the node */
                        /* that is going to be deleted */
    Data = tmp->data;
    *topPtr = tmp->nextPtr;

    free(tmp);
    return Data;
}

int isEmpty( StackNodePtr topPtr )
    //Determine if the stack is empty.
{
    if(topPtr->nextPtr==NULL)
        return 1;
    else
        return 0;
}

void printStack( StackNodePtr topPtr )
    //Print the stack.
{
    while ((topPtr->nextPtr)!=NULL){
        printf("%C",topPtr->data);
    }
    if ((topPtr->nextPtr)==NULL)
        printf("NULL");

    printStack(topPtr->nextPtr);
}

geekman

你至少应该描述一下出现什么症状，有什么Error Message吧？你这样子永远得不到答案的，没人有义务给你当人肉电脑的。

还有，请善用代码模式。

莲花

geekman 发表于 22-5-2013 02:31 PM
你至少应该描述一下出现什么症状，有什么Error Message吧？你这样子永远得不到答案的，没人有义务给你当人肉 ...

这个 function 有问题 int evaluatePostfixExpression( char *expr );
代码模式去哪里弄？

geekman

代码模式：在发帖时注意看上面的图标，<>的就是代码模式。

有问题？我还有答案咧！将Error Message写出来啊。啊不然你想别人怎么帮你哦？没有Error Message的话就描述症状，为什么你认为那个Function有错？没有任何线索之下，照我说，每一行都有嫌疑，干脆整个Fuction拖出去砍头，删了算了。

莲花

geekman 发表于 22-5-2013 07:05 PM
代码模式：在发帖时注意看上面的图标，的就是代码模式。

有问题？我还有答案咧！将Error Message写出来啊 ...

Postfix.cpp(46) : error C2664: 'strcat' : cannot convert parameter 1 from 'struct stackNode *' to 'char *'
        Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
Error executing cl.exe.

谢谢指导，我看到那个《》了

geekman

哎呀呀一看到我青筋暴涨啊。

1. 
   
2. char postfix[50];
   
3. int answer;
   

复制代码

第一件事：请慎用Global Variable！能够不用Global Variable就尽量别用，要养成每个Variable都要有适当的Scope的习惯，并忠实的遵循Variable Passing，Visible Scope等规矩，不然将来你换去学C++的时候你会痛不欲生。

1. strcat( expr , '\0' );

复制代码

这个没必要。scanf 会自动给所读取的 String 添加 null terminator。

1. for(i; postfix[i]!='\0'; i++)

复制代码

上面还似模似样的Pass Argument expr， 现在又马上变脸去直接使用Global Variable postfix，那你pass argument来干嘛？要Pass Argument那你就从头到尾用Argument，要用Global就直接Global，你这样随意跳槽或破坏Variable tracking的统一性，接手你的Source Code的人（例如你的导师）会狠狠的诅咒你的。

1. 
   
2. void push( StackNodePtr *topPtr, int value );
   
3. push(&ptrnode, postfix[i]);
   

复制代码

push接受的是一个 StackNodePtr 和一个 int，postfix[ i ]却是一个char 而且还是一个ASCII Encoded char。。。如果postfix = '0'，被推进去的不是0，而是0x30， 也就是48。。。自己想想有什么后果？

1. StackNode node;
   
2. StackNodePtr ptrnode;
   
3. ptrnode = &node;

复制代码

基本不算错，但是你没有initialize你的struct，data和nextPtr都是乱数，这时候如果你呼叫printStack（）的话，就精彩了。

1. temp = (StackNodePtr) malloc(sizeof(value));

复制代码

你只是malloc一个int的空间，但是你的struct除了一个int还有一个Node Pointer 啊啊啊啊啊啊

1. 
   
2. else if (Operator=='^')
   
3. return op1^op2;

复制代码

你确定你要计算Op1 和 Op2 的 Bitwise XOR？在C里面 a^b 并不是 a to the power of b 哦。

1. /* the new node points to NULL */

复制代码

Yeah, right, and where did the old nodes point to??

1. 
   
2. void push( StackNodePtr *topPtr, int value ) //Push a value on the stack.
   
3. {
   
4.     StackNodePtr temp; /* to create a new node */
   
5.     temp = (StackNodePtr) malloc(sizeof(value));//need Malloc because it will not remember it
   
6.     temp->data = value;
   
7.     temp->nextPtr = NULL; /* the new node points to NULL */
   
8. 
   
9.     if(isEmpty(*topPtr)==0)
   
10.     {
    
11.         temp->nextPtr = *topPtr;
    
12.     }
    
13. }
    

复制代码

so, 从一开始你的Stack就已经有个node（传说也就是你后来用到的topPtr），data并不知道有些什么数据，而nextPtr也不知道指向哪里的Node。然后你就去呼叫Push()，然后你也不管topPtr的nextPtr指向哪里，就malloc了一个int的空间，把它当作StackNotePtr来用。二话不说的把隔壁那个不知道属于谁的memory space给硬当作是nextPtr的把它给整成NULL。然后你再去看看你的topPtr的nextPtr是不是NULL？如果你的topPtr的nextPtr不是NULL的话（说真的，几率也就是50/50罢了。运气好的话。或许就是这样吧。）就把新的Node的旁边属于隔壁家的pointer空间的内容改成你的topPtr的位置？每个新Node都会指向topPtr（而且还是固定的一个Node）？这不是Stack。。。勉强解释的话，应该是梵谷的太阳花，旷世巨作啊！

你自己看看是不是很晕？（说真的我看到死去活来好几次才理解你的做法，很好，很有野兽派抽象画的风格）。

1. 
   
2. int pop( StackNodePtr *topPtr )    //Pop a value off the stack.
   
3. {
   
4.     char Data ; /* to be used to store the data */
   
5.     StackNodePtr tmp; /* to be used for handling the node*/
   
6.                                /* that is going to be deleted */
   
7.     tmp = *topPtr; /* tmp has the address of the node */
   
8.                           /* that is going to be deleted */
   
9.     Data = tmp->data;
   
10.     *topPtr = tmp->nextPtr;
    
11. 
    
12.     free(tmp);
    
13.     return Data;
    
14. }
    

复制代码

错，彻头彻尾的错。我昏死过去了好几次了，不想再自找难受了。你自己去发掘错在哪里吧。

1. printf("%C",topPtr->data);

复制代码

郑重提醒你一下：C 是 cAsE sEnSiTiVe 的。郑重提醒你二下：之前你把 char 当成 int 推进去Stack，并进行计算，虽然你现在以char来打印你的Stack，但里面已经是物是人非事事“羞”了。

1. 
   
2. void printStack( StackNodePtr topPtr )  //Print the stack.
   
3. {
   
4.     while ((topPtr->nextPtr)!=NULL)
   
5.     {
   
6.         printf("%C",topPtr->data);
   
7.     }
   
8.     if ((topPtr->nextPtr)==NULL)
   
9.         printf("NULL");
   
10. 
    
11.     printStack(topPtr->nextPtr);
    
12. }
    

复制代码

恭喜你，你成功的把自己困在N次元异空间里面了，希望你能够早日脱身出来。

能把Program写到如此彻头彻尾的错误，你也能算大师级了。彻底败服。

geekman

莲花 发表于 22-5-2013 08:37 PM
Postfix.cpp(46) : error C2664: 'strcat' : cannot convert parameter 1 from 'struct stackNode *' to  ...

问题出在这行：

1. strcat( expr , '\0' );/*Append the null character ('\0') to the end of the postfix expression.

复制代码

Postfix.cpp(46) : error C2664: 'strcat' : cannot convert parameter 1 from 'struct stackNode *' to 'char *'
        Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
Error executing cl.exe.

你确定你打出来的代码是你send给Compiler的？这里说你的strcat的第一个Argument错误，strcat要的是两个char *，而你提供给它的第一个Argument 是 struct stackNode * 类型的。可是你post出来的代码的确是char *。你确定你的代码是原装货？？？

莲花

geekman 发表于 22-5-2013 09:01 PM
哎呀呀一看到我青筋暴涨啊。第一件事：请慎用Global Variable！能够不用Global Variable就尽量别用， ...

不止你晕，我也晕。。。
这个是功课来的，我抄朋友的，但是就是run不到，所以才厚着脸皮来问~~

莲花

给我一天的时间思考，明晚才回你，我自己也搞不清楚状态~~

geekman

这是我写的，base on Single Directional Linked List 的 Stack （使用Visual C++ 2010 Express）：

1. // stack.cpp : main project file.
   
2. 
   
3. #include "stdafx.h"
   
4. #include <stdio.h>
   
5. #include <conio.h>
   
6. #include <malloc.h>
   
7. #include <memory.h>
   
8. #include <stdlib.h>
   
9. 
   
10. using namespace System;
    
11. 
    
12. struct struct_node
    
13. {
    
14.         int data;
    
15.         struct_node *next;
    
16. };
    
17. typedef struct_node Node;
    
18. typedef struct_node* NodePtr;
    
19. 
    
20. void push(int value);
    
21. int  pop(void);
    
22. void printstack(void);
    
23. 
    
24. NodePtr stack_top  = NULL;
    
25. NodePtr stack_base = NULL;
    
26. 
    
27. void main(void)
    
28. {
    
29.         int val = 0;
    
30. 
    
31.         system("cls");
    
32.         for(int i=0; i<10; i++)
    
33.         {
    
34.                 push(i);
    
35.                 printstack();
    
36.         }
    
37.         getch();
    
38. 
    
39.         while(pop() > 0)
    
40.         {               
    
41.                 printstack();
    
42.         }
    
43. 
    
44.         getch();
    
45. }
    
46. //------------------------------------------------------
    
47. void push(int value)
    
48. {
    
49.         // initialize base stack if it is not initialized already
    
50.         if(stack_top == NULL)
    
51.         {
    
52.                 stack_top = (NodePtr)malloc(sizeof(Node));
    
53.                 stack_top->data = value;
    
54.                 stack_top->next = NULL;
    
55.                
    
56.                 // stack_base will be fixed to the first element of stack
    
57.                 stack_base = stack_top;
    
58.         }
    
59.         // or add a new node if base is already initialized
    
60.         else
    
61.         {
    
62.                 NodePtr newNode = (NodePtr)malloc(sizeof(Node));
    
63.                 newNode->data = value;
    
64.                 newNode->next = NULL;
    
65.                
    
66.                 // attach the new node to the top of stack
    
67.                 stack_top->next = newNode;
    
68.                 // advance the stack_top to the latest position
    
69.                 stack_top = stack_top->next;
    
70.         }
    
71. }
    
72. //--------------------------------------------------------
    
73. int pop(void)
    
74. {
    
75.         int value;
    
76. 
    
77.         // first check if stack_top is NULL, if so, stack is empty,
    
78.         // nothing will be popped.
    
79.         if(stack_top == NULL)
    
80.                 return NULL;
    
81. 
    
82.         // then check if stack_top same as stack_base, if so, stack
    
83.         // will be empty after pop, be prepared for emptying stack
    
84.         if(stack_top == stack_base)
    
85.         {
    
86.                 value = stack_top->data;
    
87.                 free(stack_top);
    
88.                 stack_top  = NULL;
    
89.                 stack_base = NULL;
    
90.         }
    
91.         else
    
92.         {
    
93.                 value = stack_top->data;
    
94.                 // walk from stack_base till stack_top -1
    
95.                 NodePtr walker = stack_base;
    
96.                 while(walker->next != stack_top)
    
97.                 {
    
98.                         // advance walker to the next node
    
99.                         walker = walker->next;
    
100.                 }
     
101.                 // now walker is at stack_top -1
     
102.                 // severe the link between walker and stack_top
     
103.                 walker->next = NULL;
     
104.                 // free the popped node
     
105.                 free(stack_top);
     
106.                 // move stack_top to the new top
     
107.                 stack_top = walker;
     
108.         }
     
109.         return value;
     
110. }
     
111. //--------------------------------------------------------
     
112. void printstack(void)
     
113. {
     
114.         NodePtr walker = stack_base;
     
115.         
     
116.         while(walker != NULL)
     
117.         {
     
118.                 printf("%d->", walker->data);
     
119.                 walker = walker->next;
     
120.         }
     
121.         printf("END_OF_STACK\n");
     
122. }
     
123. //--------------------------------------------------------

复制代码

Stack并不是那么简单的。

莲花

geekman 发表于 22-5-2013 10:38 PM
这是我写的，base on Single Directional Linked List 的 Stack （使用Visual C++ 2010 Express）：Stack并 ...

谢了~不过这功课有指定用的function~就是这些指定的~它只给这些function name~剩下的要自己加进去~

1. struct stackNode {
   
2.     int data;
   
3.     struct stackNode *nextPtr;
   
4. };
   
5. typedef struct stackNode StackNode;
   
6. typedef StackNode *StackNodePtr;
   
7. 
   
8. int evaluatePostfixExpression( char *expr );
   
9. int calculate( int op1, int op2, char Operator );
   
10. void push( StackNodePtr *topPtr, int value );
    
11. int pop( StackNodePtr *topPtr );
    
12. int isEmpty( StackNodePtr topPtr );
    
13. void printStack( StackNodePtr topPtr );

复制代码

geekman

莲花 发表于 24-5-2013 12:07 AM
谢了~不过这功课有指定用的function~就是这些指定的~它只给这些function name~剩下的要自己加进去~

我只是告诉你stack该怎么做，功课还是得你自己做的。这次做文抄公，抄出个大头佛来，应该得到教训了吧？要抄也该找个懂的人来抄啊。

geekman

其实，仔细想想，Stack应该反过来做才有效率，Node里面的Pointer应该Point to Previous Node 才是更有效率的做法。固有观念害死人啊。

莲花

1. #include <stdlib.h>        //malloc()
   
2. #include <stdio.h>        //for printf(), scanf()
   
3. #include <string.h>        //for strlen()
   
4. #include <ctype.h>        //for toupper()
   
5. #include <io.h>                //for fflush()
   
6. #include <math.h>        //for mathematical function               
   
7. #define MAX 30//set a global variable for maximum
   
8. 
   
9. 
   
10. ////////////Prototypes////////////
    
11. int evaluatePostfixExpression (char expr[], struct stackNode **topPtr); //////////////////////////////////
    
12. int calculate (struct stackNode **topPtr, char Operator); //////////////////////////////////
    
13. void push (struct stackNode **topPtr, int); //////////////////////////////////
    
14. int pop (struct stackNode **topPtr);//////////////////////////////////
    
15. int is_empty (struct stackNode *topPtr); //////////////////////////////////
    
16. 
    
17. 
    
18. struct stackNode {                                              //structure use
    
19. int data;
    
20. struct stackNode *nextPtr;
    
21. };
    
22. 
    
23. int status = 1;
    
24. 
    
25. void main (void)
    
26. {
    
27. struct stackNode *stack = NULL;                         //pointer to node for stacking
    
28. char postfix[MAX];                                            //array for input
    
29. int answer;                                                      //answer to be displayed
    
30. 
    
31. printf("\n\n\nEnter a less than %d character postfix expression without spacing>>\n", MAX); //display message to ask user key in postfix expression
    
32. gets(postfix);                                                  //input string
    
33. answer = evaluatePostfixExpression(postfix, &stack);//evaluate expression & return answer
    
34. if(status==1)
    
35. {
    
36. printf("\nThe answer to the postfix expression is:\n"); //display message for user
    
37. printf("%s = %.1d\n", postfix, answer);                    //print output
    
38. }
    
39. }
    
40. /////////// end main() ////////////////
    
41. 
    
42. 
    
43. int evaluatePostfixExpression (char expr[], struct stackNode **topPtr) //function
    
44. {
    
45. int val, answer;                                                     //variables to be pushed onto stack
    
46. int length, i;                                                        //misc variables
    
47. length = strlen(expr);                                          //find size of string
    
48. for (i = 0; i < length && status > 0; ++i)
    
49. {
    
50. if (isdigit(expr[i]))                                               //if operand push onto stack
    
51.          {
    
52.          val = (int)(expr[i] - '0');                             //cast character as float
    
53.          push(topPtr, val);                                     //push onto stack
    
54.          }
    
55. else if(expr[i] =='+'||expr[i] =='-'||expr[i] =='*'||expr[i] =='/'||expr[i] =='%'||expr[i] =='^')   //if math crunch out answer
    
56.          {
    
57.          answer = calculate(topPtr, expr[i]);              //call func to evaluate math expr
    
58.          push(topPtr, answer);                                //push answer back on stack
    
59.          }
    
60. else                                                                   //if bad set ok_so_far = 0
    
61.          {
    
62.          printf("\nWrong value or operator entered in postfix expression.");
    
63.          status = 0;                                               //if bad value clear status
    
64.          }
    
65. }
    
66. if(status == 0)
    
67. printf("\nPlease restart program\n");
    
68. return (answer);
    
69. }
    
70. ////////////end evaluatePostfixExpression/////////////
    
71. 
    
72. 
    
73. 
    
74. void push(struct stackNode **topPtr, int pushval)
    
75. {
    
76. struct stackNode *ptr;                                 //pointer for new struct
    
77. ptr = (struct stackNode *) malloc(sizeof(struct stackNode));  //ptr is pointer to memory designated for a struct node
    
78. if(ptr == (struct stackNode *) NULL)                                 //if malloc returns NULL
    
79. {
    
80. printf("ERROR! Unable to allocate memory\n");
    
81. free(ptr);                                 //return 0 so calling function knows error occurred
    
82. }                                         //end if
    
83. else
    
84. {
    
85. ptr->nextPtr = *topPtr;                                 //point new item's link to previous node
    
86. ptr->data = pushval;                                    //assign new value into new node
    
87. *topPtr = ptr;                                              //point nodeptr to new item in list
    
88. }                //end else
    
89. }
    
90. ////////////end push/////////////////
    
91. 
    
92. 
    
93. int pop (struct stackNode **topPtr)
    
94. {
    
95. int ans;                                                                                       
    
96. struct stackNode *temp;
    
97. if (is_empty(*topPtr)== 1)                           //if stack is empty display error message
    
98. {
    
99. printf("\nERROR! Attempt to pop an empty stack quiting program");
    
100. exit(1);
     
101. }                        //end if
     
102. else
     
103. {
     
104. ans = (*topPtr)->data;
     
105. temp = *topPtr;
     
106. *topPtr = (*topPtr)->nextPtr;
     
107. free(temp);                                              //release popped node's memory back to OS
     
108. }                        //end else
     
109. return(ans);                                            //return the answer
     
110. }
     
111. ////////////end pop/////////////
     
112. 
     
113. 
     
114. int is_empty (struct stackNode *topPtr )
     
115. {
     
116. if (topPtr  == NULL)                               //if stack points to NULL there are no nodes
     
117. return(1);
     
118. return(0);
     
119. }
     
120. /////////////end is_empty//////////
     
121. 
     
122. 
     
123. int calculate (struct stackNode **topPtr, char Operator)
     
124. {
     
125. int op1, op2;                                            //operands 1 and 2
     
126. int answer;                                               //answer
     
127. op2 = pop(topPtr);                                   //pop operand 2 from stack
     
128. if(op2 == -1)
     
129. exit(1);
     
130. op1 = pop(topPtr);                                   //pop operand 1 from stack
     
131. switch(Operator)                                      //begin switch section
     
132. {
     
133. case '+':                                                  //if operator is PLUS
     
134.          answer = (op1 + op2);
     
135.          break;
     
136. 
     
137. case '-':                                                   //if operator is MINUS
     
138.          answer = (op1 - op2);
     
139.          break;
     
140. case '*':                                                   //if operator is MUTLIPLE
     
141.          answer = (op1 * op2);
     
142.          break;
     
143. case '/':                                                   //if operator is DIVIDE
     
144.          if (op2 == 0)                                  //if op2 is 0 display the error message
     
145.         {
     
146.         printf("ERROR! Attempt to divide by zero");
     
147.         exit(1);
     
148.         }
     
149.          else answer = (op1 / op2);
     
150.          break;
     
151. case '%':                                                  //if the operator is MODULUS
     
152.          answer = (op1 % op2);
     
153.          break;
     
154. case '^':                                                   //if the operator is POWER
     
155.          answer = (pow(op1,op2));
     
156.          break;
     
157. 
     
158. }                //end switch section
     
159. return (answer);                                       //return answer to calling function
     
160. }
     
161. ////////////end calculate///////////
     

复制代码

geekman

莲花 发表于 31-5-2013 02:12 AM

How may I help you?

莲花

geekman 发表于 31-5-2013 10:17 AM
How may I help you?

只是想要跟你讲我解决了，谢谢你一直回复我~~

莲花

SotongJiang 发表于 31-5-2013 10:58 PM
geekman的耐心真好，循循善诱，希望莲花能明白你的好意。

我学校的老师都没有他酱好心咯~~

geekman

我以前求学时也曾被不负责任的Programming老师深深地伤害过单纯幼嫩的心灵，所以并不想让现在的幼苗们受到我曾遭遇的无助的困境。

只是我的言论有时会尖酸刻薄了点，希望大家别介意啊哈，毕竟本性难移啊。