函数指针，做题的时候遇到困惑了

newonejoe

具体代码如下

1. /* Exercise 6-4. Write a program that prints the distinct words in its input sorted into decreasing order of frequency of occurrence. Precede each word by its count */
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <string.h>
   
5. #include <ctype.h>
   
6. 
   
7. #define MAXLEN 100
   
8. #define MAXWORD 1000
   
9. 
   
10. struct tnode {
    
11.     char *word;
    
12.     int count;
    
13.     struct tnode * left;
    
14.     struct tnode * right;
    
15. };
    
16. 
    
17. struct key
    
18. {
    
19.     char *word;
    
20.     int count;
    
21. };
    
22. 
    
23. int getword(char *, int);
    
24. struct tnode * addtree(struct tnode *, char *);
    
25. void treeprint(struct tnode *);
    
26. void treeToKeyTab(struct tnode *);
    
27. void word_qsort(void *v[], int left, int right, int (*comp)(void *, void *));
    
28. int keycomp(struct key * , struct key *);
    
29. void swap(void *v[], int , int);
    
30. 
    
31. int nodecount = 0;
    
32. struct key wordtab[ MAXWORD];
    
33. int wordcounter = 0;
    
34. 
    
35. /* display word in count decreasing order */
    
36. int main(void)
    
37. {
    
38.     int cond;
    
39.     char word[MAXLEN];
    
40. 
    
41.     struct tnode * root = NULL;
    
42. 
    
43.     while ((cond = getword(word, MAXLEN)) != EOF)
    
44.     {
    
45.         if (isalpha(*word))
    
46.             root = addtree(root, word);
    
47.     }
    
48.     treeprint(root);
    
49.     printf("-----------\n");
    
50.     treeToKeyTab(root);
    
51. 
    
52.     for (int i = 0; i < nodecount; i++)
    
53.         printf("%4d %s\n", (wordtab+i)->count, (wordtab+i)->word);
    
54. 
    
55.     printf("-----------\n");
    
56. 
    
57.     // sort the struct key array
    
58.     //void word_qsort(void *v[], int left, int right, int (*comp)(void *, void *));
    
59.     //int keycomp(struct key*, struct key*);
    
60.     word_qsort((void **)wordtab, 0, nodecount-1, (int (*)(void *, void *))keycomp);
    
61. 
    
62.     for (int i = 0; i < nodecount; i++)
    
63.         printf("%4d %s\n", (wordtab+i)->count, (wordtab+i)->word);
    
64.     return 0;
    
65. }
    
66. 
    
67. 
    
68. /* getword: getword and return */
    
69. int getword(char * word, int lim)
    
70. {
    
71.     int c, i = 0;
    
72.     while (isspace(c = getc(stdin)))
    
73.         ;
    
74.     if (c == EOF)
    
75.         return c;
    
76.     if (!isalpha(c)) {
    
77.         word[0] = c;
    
78.         return word[0];
    
79.     }
    
80.     do {
    
81.         word[i++] = c;
    
82.     } while (isalpha(c = getc(stdin)) && i < lim);
    
83.     word[i] = '\0';
    
84.     ungetc(c, stdin);
    
85.     return c;
    
86. }
    
87. 
    
88. /* addtree: add word into exist node or create new node */
    
89. struct tnode * addtree(struct tnode *p, char *w)
    
90. {
    
91.     int cond;
    
92.     if (p == NULL) {
    
93.         p = (struct tnode *)malloc(sizeof(struct tnode));
    
94.         p->word = (char *)malloc(sizeof(char) * MAXLEN);
    
95.         strcpy(p->word, w);
    
96.         p->count = 1;
    
97.         p->left = p->right = NULL;
    
98.         nodecount++;        //count the treenode numbers
    
99.     } else {
    
100.         if ((cond = strcmp(w, p->word)) == 0 ){
     
101.             p->count++;   
     
102.         } else if (cond < 0) {
     
103.             p->left = addtree(p->left, w);
     
104.         } else {            
     
105.             p->right = addtree(p->right, w);
     
106.         }
     
107.     }   
     
108.     return p;
     
109. }
     
110. 
     
111. /* treeprint:   print the word */
     
112. void treeprint(struct tnode *p)
     
113. {
     
114.     if ( p ) {
     
115.         treeprint(p->left);
     
116.         printf("%4d %s\n", p->count, p->word);
     
117.         treeprint(p->right);
     
118.     }
     
119. }
     
120. 
     
121. /* treeToKeyTab */
     
122. void treeToKeyTab(struct tnode *p)
     
123. {
     
124.     if (p != NULL)
     
125.     {
     
126.         treeToKeyTab(p->left);
     
127.         (wordtab+wordcounter)->word = strdup(p->word);
     
128.         (wordtab+wordcounter)->count = p->count;
     
129.         wordcounter++;
     
130.         treeToKeyTab(p->right);
     
131.     }
     
132. }
     
133. /* qsort: sort v[left]...v[right] into increasing order */
     
134. void word_qsort(void *v[], int left, int right, int (*comp)(void *, void *))
     
135. {
     
136.     int i, last;
     
137.    
     
138.     if (left >= right)
     
139.         return;
     
140.     // use the v[(left + right) / 2]as compare target
     
141.     swap(v, left, (left + right)/2);
     
142.     last = left;
     
143.     for (i = left + 1; i <= right; i++)
     
144.     {
     
145.         printf("%ld", sizeof(v[i]));
     
146.         if ((*comp)(v[i], v[left]) < 0)
     
147.         {
     
148.             printf("comp\n");
     
149.             swap(v, ++last, i);
     
150.         }
     
151.     }
     
152.     swap(v, left, last);
     
153.     word_qsort(v, left, last-1, comp);
     
154.     word_qsort(v, last+1, right, comp);
     
155. }
     
156. 
     
157. /* swap:    swap two */
     
158. void swap(void *v[], int i, int j)
     
159. {
     
160.     void *temp;
     
161. 
     
162.     temp = v[i];
     
163.     v[i] = v[j];
     
164.     v[j] = temp;
     
165. }
     
166. 
     
167. /* comp:    struct compare */
     
168. int keycomp(struct key * v1, struct key *v2)
     
169. {
     
170.     int cond;
     
171.     if (v1->count > v2->count)
     
172.         return 1;
     
173.     else if (v1->count < v2->count)
     
174.         return -1;
     
175.     else {
     
176.         if ((cond = strcmp(v1->word, v2->word)) > 0)
     
177.             return 1;
     
178.         else if (cond < 0 )
     
179.             return -1;
     
180.         else
     
181.             return 0;
     
182.     }
     
183. }

复制代码

快速排序程序的声明如下：
void word_qsort(void *v[], int left, int right,  int(*comp)(void *, void *));
其中int(*comp)(void *, void *)是一个函数指针，意思是：
该函数指针指向一个函数，该函数的返回值是int类型

然后我在main函数中调用该函数的语句是：
word_sort((void **)wordtab, 0, node count-1, (int (*)(void *, void *))keycomp);
其中wordtab是结构体数组，keycomp是一个比较函数
wordtab的结构体是
struct key {
    char *word;
    int count;
};

keycamp函数的声明如下
int keycomp(struct key * v1, struct key *v2);
我运行的时候每次在调用keycomp函数是进行不下去，好像是指针转换过程中出了问题，具体的请帮忙分析。

hanzhenlll

兄弟可以把指针的地址打出来看看，初始化把指针 设置为NULL 更容易找出问题。

fender0107401

自己单步调试一下。

action08

如果是学生没必要纠结这些东西，方向思想都太边缘了，
计算机工程还有更多的方向需要人们去探索，即使商业价值也没有多少，也就是技术中层管理干部不干活专牛角的功夫