请帮忙改下程序，输出以ABCD排列

晚起鸟儿

#include<stdio.h>
#include<conio.h>
char one,two;

float num1, num2;
int main(){
  scanf("%c%f%c%f",&one,&num1,&two,&num2);
if(one=='A')
{
  printf("%c%f%c%f\n",one,num1,two,num2);  
}
else if(one=='B')
{
  printf("%c%f%c%f\n",two,num2,one,num1);
}
getch();
},three,four
以上为输入两个大写字母A和B,（输入不以字母顺序输入）字母后面各附带一个实数，
输出结果以AB及后面带的数值排列~

我想弄成可以随机输入1－4个字母及对应实数，只能输入A,或者输入A,B或者输入A,B,C或者输入A,B,C,D，
（输入不以字母顺序输入）每个字母后面各有一个实数，输出结果按字母表顺序输出，
并且字母后面带的实数跟在字母后面，比如保持num1在one后面，num4在four后面

ljd884497

这是根据你的要求写的。
# include <stdio.h>
# include <ctype.h>
# include <stdlib.h>
# define NUM 20
struct ljd              //定义一个存放 字母和数字的结构
{
        char letter;
        double number;
};
int main()
{
        struct ljd *pf[NUM] = {NULL};  //声明多个指向结构体的指针用于指向保存输入的数据
        struct ljd *temp;                 // 声明一个临时的指针用于指针的交换
        char buf[256];                   //  用于接受原始码
        int i = 0;                           // 循环计数
        int k = 0;                          // 循环计数
        int j = 0;                           // 循环计数
        char TempString[20];        // 临时字符串，用于从原始码中取出的字符串的存放
        char TempChar;               // 临时字符，用于从原始码中取出的字符的存放
        double TempNum = 0.0;  // 临时变量，用于把字符串转换成数字


        printf ("请输入原始码：");
        gets(buf);                //接受所有输入的

        while(buf[i] != '\0')       //循环查找字母和数字，并分开提取
        {
                if (isalpha(buf[i]))  // 如果是字母，则 开辟一个结构体内存，用于保存字母和数据
                {
                        TempChar = buf[i];
                        pf[j] = (struct ljd *)malloc(sizeof(struct ljd));
                        pf[j]->letter = TempChar;     // 这里保存的是字母
                        i++;
                }
                else                                   /* 如果是数字，则开始循环查找这个数字的结尾（只到另一个字母）*/
                {
                        while (!isalpha(buf[i+k]) && buf[i+k] != '\0')
                        {
                                TempString[k] = buf[i+k];
                                k++;
                        }
                        TempString[k] = '\0';  //到这里，提取的数字还是字符串，所以下面要有atof()转换成数字
                        TempNum = atof(TempString);
                        pf[j]->number = TempNum;
                        j++;
                        i += k;

                }
               
                k = 0; // 循环结束时，要把k清零，以便下一次查找数字是从0开始循环
        

               
        }
        for (i = 0;i < j;i++)    // 这里是给保存的结构数据按字母从小到大排列
        {
                for (k=i+1;k < j;k++)
                {
                        if (pf[i]->letter > pf[k]->letter)
                        {
                                temp = pf[i];
                                pf[i]= pf[k];
                                pf[k] = temp;
                        }
                }

        }



        for (i = 0;i < j;i++)  // 正常循环输出
        {
                printf ("%c %.2lf  ",pf[i]->letter,pf[i]->number);
                free(pf[i]);
                pf[i] = NULL;
        }

        printf("\n");
        system("pause");

        return 0;
}

人造人

不理解题意
假如我输入的是
c 1.2 e 2 会输出什么
r 9 w 2.4 t 3 g 0.0 会输出什么？
话说，我这样输入对吗？
如果对那输出是
c 1 e 2
g 0 r 9 t 3 w 2
吗？

晚起鸟儿

人造人 发表于 2016-7-12 22:23
不理解题意
假如我输入的是
c 1.2 e 2 会输出什么

当然不行，首先是大写字母，而且只能是A,或者输入A,B或者输入A,B,C或者输入A,B,C,D（输入不以字母顺序输入）其他显示“输入有误，请重新输入”就行了~

小剑剑

1. #include<stdio.h>
   
2. #include<conio.h>
   
3. int main(){
   
4.     char charity[5]="ABCD";
   
5.     float number[4];
   
6.     scanf("%f%f",number,number+1);
   
7.     if(number[0]<number[1])
   
8.     {
   
9.     printf("%c%f%c%f\n",charity[0],*number,charity[1],*(number+1));
   
10.     }
    
11.     else
    
12.     {
    
13.     printf("%c%f%c%f\n",charity[1],*(number+1),charity[0],*number);
    
14.     }
    
15.     getch();
    
16.             }
    

复制代码

只输入数字，不输入字母

人造人

晚起鸟儿 发表于 2016-7-13 03:45
当然不行，首先是大写字母，而且只能是A,或者输入A,B或者输入A,B,C或者输入A,B,C,D（输入不以字母顺序输 ...

这样？
A 2.3 C 4.1 D 5.0
B 1.1
D 4.4 A 1.3 C 4.0
输出
A 2.3 C 4.1 D 5.0
B 1.1
A 1.3 C 4.0 D 4.4

晚起鸟儿

人造人 发表于 2016-7-13 09:58
这样？
A 2.3 C 4.1 D 5.0
B 1.1

对呀，这正是我想要的结果，随机输入的哦

晚起鸟儿

小剑剑 发表于 2016-7-13 09:22
只输入数字，不输入字母

这样的不行哦，而且只能比较前两个数，但代码写得很简练

人造人

晚起鸟儿 发表于 2016-7-13 12:18
对呀，这正是我想要的结果，随机输入的哦

1. #include <stdio.h>
   
2. #include <string.h>
   
3. #include <windows.h>
   
4. 
   
5. #define MAX_BUFF_LEN 100 // 输入不能超过 50 个字符
   
6. #define ALPHABET_NUM 4 //字母个数，在这里是4，即 A B C D  
   
7. 
   
8. 
   
9. 
   
10. 
    
11. /* real_num_str_len
    
12.         参数 str ：  包含有实数的字符串(实数前面可以有空格)
    
13.        
    
14.         返回值 ：
    
15.                 -3  (一个很长的实数 )
    
16.                 -2 （实数前面空格太多 ）
    
17.                 -1 （字符串中是有实数，但是字符串以字母开始）
    
18.                
    
19.          函数返回 : 实数字符串的长度（实数前面可以有空格）
    
20.         举个例子
    
21.         字符串 "      123.45000   90.0"  函数返回  15 （从一开始到123.45000 ，0后面）
    
22.         字符串 " 54.3   abc"  函数返回  5 （从一开始到54.3, 3后面）
    
23.         如果字符串不是 实数字符串
    
24.         例如 字符串 "a 123.30" 字符串中是有实数，但是字符串以字母开始，所以不算，这种情况返回 -1
    
25. 
    
26. */
    
27. int real_num_str_len(char const *str)
    
28. {
    
29.         int ret = 0;
    
30.         int decimal_point_flag = 0; //小数点标志
    
31.         int ret_bak = 0;
    
32.        
    
33.         while(*str == ' ')
    
34.         {
    
35.                 ret++;
    
36.                 if(ret >= 100) // 实数前面空格太多，继续下去可能会死循环
    
37.                 {
    
38.                         return -2;
    
39.                 }
    
40.                 str++;
    
41.         }
    
42.        
    
43.         ret_bak = ret; // 备份ret
    
44.         while(1)
    
45.         {
    
46.                 if( (*str < '0') || (*str > '9') )
    
47.                 {
    
48.                         switch(*str)
    
49.                         {
    
50.                                 case '+' :
    
51.                                 case '-' :
    
52.                                         break;
    
53.                                        
    
54.                                 case '.' :
    
55.                                        
    
56.                                         if(decimal_point_flag == 1) // 已经有一个小数点了，现在又有一个，就在这里结束吧
    
57.                                         {
    
58.                                                 return ret;
    
59.                                         }
    
60.                                         else
    
61.                                         {
    
62.                                                 decimal_point_flag = 1;
    
63.                                         }
    
64.                                        
    
65.                                         break;
    
66.                                        
    
67.                                 default :
    
68.                                         return ret;
    
69.                                                        
    
70.                         }
    
71.                 }
    
72.                
    
73.                 ret++;
    
74.                 str++;
    
75.                
    
76.                
    
77.                 if(ret - ret_bak > 50) // 一个很长的实数，报错吧
    
78.                 {
    
79.                         return -3;
    
80.                 }
    
81.         }
    
82.        
    
83. }
    
84. 
    
85. int str_handler(char *buff)
    
86. {
    
87.        
    
88.         char *str_temp[ALPHABET_NUM];
    
89.         int block_len = 0; // 一个字符和字符后面的实数分成一个块
    
90.         int i = 0;
    
91.         int j = 0;
    
92.         char *new_buff = NULL;
    
93.         int blank_space = 0;
    
94.         int blank_count = 0;
    
95.        
    
96.         while(1) // 检查字符串，并把字符串分成块放在 str_temp
    
97.         {
    
98.                
    
99.                 while(buff[i] == ' ') // 去掉每个块前面的空格
    
100.                 {
     
101.                         blank_space++;
     
102.                         if(blank_space >= 100) // 块前面空格太多，继续下去可能会死循环
     
103.                         {
     
104.                                 return -3;
     
105.                         }
     
106.                         i++;
     
107.                 }
     
108.                
     
109.                 switch(buff[i])
     
110.                 {
     
111.                         case '\n' :
     
112.                                 goto next;
     
113.                                
     
114.                                
     
115.                         case 'A' : // no break
     
116.                         case 'B' : // no break
     
117.                         case 'C' : // no break
     
118.                         case 'D' :
     
119.                                
     
120.                                 block_len = real_num_str_len(&buff[i + 1]);
     
121.                                 if(block_len < 0)
     
122.                                 {
     
123.                                         return -1;
     
124.                                 }
     
125.                                 block_len++; // 指向下一个块
     
126.                                
     
127.                                 new_buff = malloc(block_len + 1);
     
128.                                 if(new_buff == NULL) // 无法申请内存
     
129.                                 {
     
130.                                         return -2;
     
131.                                 }
     
132.                                
     
133.                                 strncpy(new_buff, &buff[i], block_len);
     
134.                                 *(new_buff + block_len) = '\0';
     
135.                                 str_temp[blank_count] = new_buff;
     
136.                                
     
137.                                 break;
     
138.                        
     
139.                         default : return -1;
     
140.                 }
     
141.                
     
142.                 i += block_len;
     
143.                 blank_count++;
     
144.                
     
145.                 if(buff[i] == '\n') // 已经确定字符串没有问题，并且字符串已经按块放在 str_temp
     
146.                 {
     
147.                         break;
     
148.                 }
     
149.         }
     
150. next:       
     
151.         // 下面开始排序
     
152. 
     
153. 
     
154.         for(i = 0; i < blank_count - 1; i++)
     
155.         {
     
156.                 for(j = 0; j < blank_count - i - 1; j++)
     
157.                 {
     
158.                         if(str_temp[j][0] < str_temp[j + 1][0])
     
159.                         {
     
160.                                 char *temp = str_temp[j];
     
161.                                 str_temp[j] = str_temp[j + 1];
     
162.                                 str_temp[j + 1] = temp;
     
163.                         }
     
164.                 }
     
165.         }               
     
166. 
     
167.        
     
168.         //排序完成，现在把str_temp 复制到 buff 就真的完事了
     
169.        
     
170.         *buff = '\0';
     
171.         for(i = blank_count - 1; i >= 0; i--)
     
172.         {
     
173.                 strcat(buff, str_temp[i]);
     
174.                 strcat(buff, " "); // 在两个块之间加入空格
     
175.                 free(str_temp[i]); // 释放通过 malloc 申请的内存
     
176.         }
     
177. 
     
178.        
     
179.         return 0;
     
180. }
     
181. 
     
182. int main(void)
     
183. {
     
184.         char buff[MAX_BUFF_LEN];
     
185.        
     
186.        
     
187.         printf("请输入：");
     
188.         while(1)
     
189.         {
     
190.                 fgets(buff, MAX_BUFF_LEN, stdin);
     
191.                
     
192.                 if(str_handler(buff) == 0) //str_handler 返回0 表示字符串没有问题，并且已经排序
     
193.                 {
     
194.                         break;
     
195.                 }
     
196.                
     
197.                 printf("输入有误，请重新输入：");
     
198.         }
     
199.        
     
200.         printf("%s\n", buff);
     
201.        
     
202.        
     
203.         system("pause");
     
204.         return 0;
     
205. }
     

复制代码

晚起鸟儿

人造人 发表于 2016-7-14 00:10

vc6.0运行好多报错，请问是不是需要用高些的版本运行，或者您是用ＶＳ？

donkkong

首先肯定一点，与编译器无关，另外你的疑问应该是设计一个程序，可以做到排序功能，这个会涉及到冒泡算法，以后会在鱼c视频里面学到，所以可以先不急
另外如果要实现排序，或比较，最好是将内存储存的数据对掉，而不是更改输出(printf)的顺序，举个例子
char ch1, ch2, ch3, ch4;
scanf("%c%c%c%c",&ch1,&ch2,&ch3,&ch4,);//随机输入例如DBCA
if(...........)
{
     .........................//算法代码段,用于将&ch1,&ch2,&ch3,&ch4的内容换成ABCD
}
printf("%c%c%c%c\n",ch1, ch2, ch3, ch4);//显示器输出ABCD，输出顺序是不应该改变的，
也不确定你是否理解，以为我之前看你的思路是改变输出顺序，而没有想其实应该改变储存顺序才对

人造人

晚起鸟儿 发表于 2016-7-14 06:17
vc6.0运行好多报错，请问是不是需要用高些的版本运行，或者您是用ＶＳ？

#include <stdlib.h>
加上这个，我是用 c-free 不加 #include <stdlib.h> 也能啊
你加上这个试试

晚起鸟儿

人造人 发表于 2016-7-14 12:34
#include
加上这个，我是用 c-free 不加 #include  也能啊
你加上这个试试

加了还是报错
D:\Microsoft Visual Studio\MyProjects\tiao\tiao.c(29) : error C2084: function 'int __cdecl real_num_str_len(const char *)' already has a body
D:\Microsoft Visual Studio\MyProjects\tiao\tiao.c(84) : error C2084: function 'int __cdecl str_handler(char *)' already has a body
D:\Microsoft Visual Studio\MyProjects\tiao\tiao.c(181) : error C2084: function 'int __cdecl main(void )' already has a body
执行 cl.exe 时出错.

程序好复杂，看不懂的说，辛苦了~

晚起鸟儿

donkkong 发表于 2016-7-14 11:49
首先肯定一点，与编译器无关，另外你的疑问应该是设计一个程序，可以做到排序功能，这个会涉及到冒泡算法， ...

if(......)最后一个不用判断也有十二种可能呀，当然这样比较直观，但是代码量还要冗长得多……

我的想法是设定Ａ>Ｂ>Ｃ>Ｄ,然后查找这四个字母的位置，按从小到大顺序排列，不知是否要用到ascll码，
具体怎样写也弄不来呀~

人造人

晚起鸟儿 发表于 2016-7-14 14:32
加了还是报错
D:\Microsoft Visual Studio\MyProjects\tiao\tiao.c(29) : error C2084: function 'int _ ...

c-free 下没有问题，vs2015 下也没有问题，
你好像是多写了一份，把现在的程序删除（如果需要，请备份），重新复制这个

1. #include <stdio.h>
   
2. #include <string.h>
   
3. #include <windows.h>
   
4. #include <stdlib.h>
   
5. 
   
6. #define MAX_BUFF_LEN 100 // 输入不能超过 50 个字符
   
7. #define ALPHABET_NUM 4 //字母个数，在这里是4，即 A B C D  
   
8. 
   
9. 
   
10. 
    
11. 
    
12. /* real_num_str_len
    
13.         参数 str ：  包含有实数的字符串(实数前面可以有空格)
    
14.         
    
15.         返回值 ：
    
16.                 -3  (一个很长的实数 )
    
17.                 -2 （实数前面空格太多 ）
    
18.                 -1 （字符串中是有实数，但是字符串以字母开始）
    
19.                
    
20.          函数返回 : 实数字符串的长度（实数前面可以有空格）
    
21.         举个例子
    
22.         字符串 "      123.45000   90.0"  函数返回  15 （从一开始到123.45000 ，0后面）
    
23.         字符串 " 54.3   abc"  函数返回  5 （从一开始到54.3, 3后面）
    
24.         如果字符串不是 实数字符串
    
25.         例如 字符串 "a 123.30" 字符串中是有实数，但是字符串以字母开始，所以不算，这种情况返回 -1
    
26. 
    
27. */
    
28. int real_num_str_len(char const *str)
    
29. {
    
30.         int ret = 0;
    
31.         int decimal_point_flag = 0; //小数点标志
    
32.         int ret_bak = 0;
    
33.         
    
34.         while(*str == ' ')
    
35.         {
    
36.                 ret++;
    
37.                 if(ret >= 100) // 实数前面空格太多，继续下去可能会死循环
    
38.                 {
    
39.                         return -2;
    
40.                 }
    
41.                 str++;
    
42.         }
    
43.         
    
44.         ret_bak = ret; // 备份ret
    
45.         while(1)
    
46.         {
    
47.                 if( (*str < '0') || (*str > '9') )
    
48.                 {
    
49.                         switch(*str)
    
50.                         {
    
51.                                 case '+' :
    
52.                                 case '-' :
    
53.                                         break;
    
54.                                        
    
55.                                 case '.' :
    
56.                                        
    
57.                                         if(decimal_point_flag == 1) // 已经有一个小数点了，现在又有一个，就在这里结束吧
    
58.                                         {
    
59.                                                 return ret;
    
60.                                         }
    
61.                                         else
    
62.                                         {
    
63.                                                 decimal_point_flag = 1;
    
64.                                         }
    
65.                                        
    
66.                                         break;
    
67.                                        
    
68.                                 default :
    
69.                                         return ret;
    
70.                                                         
    
71.                         }
    
72.                 }
    
73.                
    
74.                 ret++;
    
75.                 str++;
    
76.                
    
77.                
    
78.                 if(ret - ret_bak > 50) // 一个很长的实数，报错吧
    
79.                 {
    
80.                         return -3;
    
81.                 }
    
82.         }
    
83.         
    
84. }
    
85. 
    
86. int str_handler(char *buff)
    
87. {
    
88.         
    
89.         char *str_temp[ALPHABET_NUM];
    
90.         int block_len = 0; // 一个字符和字符后面的实数分成一个块
    
91.         int i = 0;
    
92.         int j = 0;
    
93.         char *new_buff = NULL;
    
94.         int blank_space = 0;
    
95.         int blank_count = 0;
    
96.         
    
97.         while(1) // 检查字符串，并把字符串分成块放在 str_temp
    
98.         {
    
99.                
    
100.                 while(buff[i] == ' ') // 去掉每个块前面的空格
     
101.                 {
     
102.                         blank_space++;
     
103.                         if(blank_space >= 100) // 块前面空格太多，继续下去可能会死循环
     
104.                         {
     
105.                                 return -3;
     
106.                         }
     
107.                         i++;
     
108.                 }
     
109.                
     
110.                 switch(buff[i])
     
111.                 {
     
112.                         case '\n' :
     
113.                                 goto next;
     
114.                                 
     
115.                                 
     
116.                         case 'A' : // no break
     
117.                         case 'B' : // no break
     
118.                         case 'C' : // no break
     
119.                         case 'D' :
     
120.                                 
     
121.                                 block_len = real_num_str_len(&buff[i + 1]);
     
122.                                 if(block_len < 0)
     
123.                                 {
     
124.                                         return -1;
     
125.                                 }
     
126.                                 block_len++; // 指向下一个块
     
127.                                 
     
128.                                 new_buff = malloc(block_len + 1);
     
129.                                 if(new_buff == NULL) // 无法申请内存
     
130.                                 {
     
131.                                         return -2;
     
132.                                 }
     
133.                                 
     
134.                                 strncpy(new_buff, &buff[i], block_len);
     
135.                                 *(new_buff + block_len) = '\0';
     
136.                                 str_temp[blank_count] = new_buff;
     
137.                                 
     
138.                                 break;
     
139.                         
     
140.                         default : return -1;
     
141.                 }
     
142.                
     
143.                 i += block_len;
     
144.                 blank_count++;
     
145.                
     
146.                 if(buff[i] == '\n') // 已经确定字符串没有问题，并且字符串已经按块放在 str_temp
     
147.                 {
     
148.                         break;
     
149.                 }
     
150.         }
     
151. next:        
     
152.         // 下面开始排序
     
153. 
     
154. 
     
155.         for(i = 0; i < blank_count - 1; i++)
     
156.         {
     
157.                 for(j = 0; j < blank_count - i - 1; j++)
     
158.                 {
     
159.                         if(str_temp[j][0] < str_temp[j + 1][0])
     
160.                         {
     
161.                                 char *temp = str_temp[j];
     
162.                                 str_temp[j] = str_temp[j + 1];
     
163.                                 str_temp[j + 1] = temp;
     
164.                         }
     
165.                 }
     
166.         }               
     
167. 
     
168.         
     
169.         //排序完成，现在把str_temp 复制到 buff 就真的完事了
     
170.         
     
171.         *buff = '\0';
     
172.         for(i = blank_count - 1; i >= 0; i--)
     
173.         {
     
174.                 strcat(buff, str_temp[i]);
     
175.                 strcat(buff, " "); // 在两个块之间加入空格
     
176.                 free(str_temp[i]); // 释放通过 malloc 申请的内存
     
177.         }
     
178. 
     
179.         
     
180.         return 0;
     
181. }
     
182. 
     
183. int main(void)
     
184. {
     
185.         char buff[MAX_BUFF_LEN];
     
186.         
     
187.         
     
188.         printf("请输入：");
     
189.         while(1)
     
190.         {
     
191.                 fgets(buff, MAX_BUFF_LEN, stdin);
     
192.                
     
193.                 if(str_handler(buff) == 0) //str_handler 返回0 表示字符串没有问题，并且已经排序
     
194.                 {
     
195.                         break;
     
196.                 }
     
197.                
     
198.                 printf("输入有误，请重新输入：");
     
199.         }
     
200.         
     
201.         printf("%s\n", buff);
     
202.         
     
203.         
     
204.         system("pause");
     
205.         return 0;
     
206. }
     

复制代码

人造人

晚起鸟儿 发表于 2016-7-14 14:32
加了还是报错
D:\Microsoft Visual Studio\MyProjects\tiao\tiao.c(29) : error C2084: function 'int _ ...

你遇到的问题其他人也遇到了，看https://www.so.com/s?q=function+%27int+__cdecl+main(void+)%27+already+has+a+body&src=srp&fr=360chrome_toolbar_search&psid=c1bfa9aec646690ec81dffd45aaeb109
建议换一个编译系统吧，vc6适合初学者，你不是初学者吧，vs 2015 ，c-free都很不错

晚起鸟儿

人造人 发表于 2016-7-14 15:29
c-free 下没有问题，vs2015 下也没有问题，
你好像是多写了一份，把现在的程序删除（如果需要，请备份） ...

还是不行，删了重新复制粘贴也不行，我的是ＶＣ++６.０，没有多写，一样是２０６行

人造人

晚起鸟儿 发表于 2016-7-14 15:43
还是不行，删了重新复制粘贴也不行，我的是ＶＣ++６.０，没有多写，一样是２０６行

http://www.tuxi.com.cn/888-11825-118252201.html

晚起鸟儿

人造人 发表于 2016-7-14 15:44
http://www.tuxi.com.cn/888-11825-118252201.html

说实在的，我觉得您程序写得太复杂，虽然注释很详细，但我这菜鸟还是无法理解，应该可以更简单些的，c-free以前下载过，因为是跟鱼总视频练习，鱼总用ＶＣ６,没英文基础的菜鸟我无法适应用别的软件~

人造人

晚起鸟儿 发表于 2016-7-15 13:32
说实在的，我觉得您程序写得太复杂，虽然注释很详细，但我这菜鸟还是无法理解，应该可以更简单些的，c-fr ...

为了程序的健壮性，这样是值得的，想想一个程序因为用户的错误输入或是故意刁难的输入，程序就死机或是莫名其妙的输出，我无法忍受这样的结果，还有c-free 可以是中文的呀