在Linuc C下有没有把整个字符串(仅为字母)转换成小写字母或大写字母的吗？

YSM

在Linuc C下有没有把整个字符串转换成小写字母或大写字母的吗？

libinary

我没见过，其实也简单：

1. 
   
2. for(i = 0; i < strlen(s); i++)
   
3.   s[i] = toupper(s[i]);
   

复制代码

无双

这样更简单

char *p = s;
while(toupper(*p++));

没有调过
大家可以试试看吧

quanliking

1. 
   
2. #include <stdio.h>
   
3. 
   
4. char my_toupper(char);
   
5. 
   
6. int main()
   
7. {
   
8.         char s[] = "hello, world!";
   
9.         int i;
   
10.         for(i = 0; i < strlen(s); i++)
    
11.                 s[i] = my_toupper(s[i]);
    
12.         printf("%s\n", s);
    
13. 
    
14.         return 0;
    
15. }
    
16. 
    
17. char my_toupper(char c)
    
18. {
    
19.         if ( c >= 'a' && c <= 'z')
    
20.                 return c =  c - 'a' + 'A';
    
21.         else
    
22.                 return c;
    
23. }
    

复制代码

写了个简陋的 my_toupper() 函数,当然没 toupper() 好了。

1. 
   
2. char *p = s;
   
3. while(toupper(*p++));
   

复制代码

要改一下。

1. 
   
2. char *p = s;
   
3. while(*p = toupper(*p++));
   

复制代码

看起来挺危险的。

syisyi

char *p = s;
while(*p = toupper(*p++));

写了段代码测了一下，run OK.
但是还是不太清楚p++的运算顺序，是不是当执行完*p=toupper(*p)的时候，才发生p++这个动作？是当“++”运算符所在的表达式执行完之后才发生++这个动作吗（当然指++在后，即p++，而非++p的情况）？那么请看如下：

#include <stdio.h>
#include <assert.h>

int main()
{
    int i=3;
    assert(i == i);
    printf("%d %d",i++,i++);
}
在这段程序中，输出结果为"3 4"，这种情况应该怎么理解？而如果把assert(i == i)，也为assert(i++ == i)或assert(i == i++)或assert (i++ == i++) ，全都会断言失败，能不能给讲一下，实在蒙的很。尤其是assert(i++ == i)竟然断言失败，实在不解。
以上程序测试平台cygwin

libinary

这种东西属于“未定义”，其结果不一定是什么，完全取决于编译器的实现，每一种编译器得到的结果都不一样，应该尽量避免。

syisyi

未定义可以理解，呵呵，原来我记得书上也这么说的，像printf的参数列表的运算顺序，取决于具体编译器的实现，有的从左向右，有的从右向左。问题是assert(i++ = i) ; assert(i == i++) ; assert(i++ == i++) ; 竟然没有一个断言成功，实在费解啊。原来的时候，深的原则也不清楚，++的程序还敢写，现在比原来知道的多点，反而胆子更小了，而且感觉上面那段程序用 *p++ = toupper(*p) 更放心些。

无双

因为assert是一个宏
而不是一个函数

宏可以包含多个语句


后++表示执行完这个句子后再++
想法于
*p = upper(*p);
p++;
\这两个语句的组合

syisyi

头疼，记得等号运算顺序是从右向左，这里怎么变成从左向右了？

1. #include <stdio.h>
   
2. 
   
3. int main()
   
4. {
   
5.     char str[]="abcdefg";
   
6.     char *p=str;
   
7. 
   
8.     puts("");
   
9.     *p=*p++;
   
10.     puts(p);
    
11.     puts(str);
    
12.     *p++=*p;
    
13.     puts(p);
    
14.     puts(str);
    
15.     *++p=*p;
    
16.     puts(p);
    
17.     puts(str);
    
18.     *p=*++p;
    
19.     puts(p);
    
20.     puts(str);
    
21.    
    
22.     puts("");
    
23.     strcpy(str,"abcdefg");
    
24.     p=str;  
    
25.     while(*p=toupper(*p++));
    
26.     puts(str);
    
27.     p=str;  
    
28.     while(*p++=tolower(*p));
    
29.     puts(str);
    
30.     p=str;  
    
31.     while(*p=toupper(*++p));
    
32.     puts(str);
    
33.     p=str;  
    
34.     while(*++p=tolower(*p));
    
35.     puts(str);
    
36. }

复制代码

输出结果如下：
[root@localhost test]# ./test2

bcdefg
abcdefg
cdefg
abcdefg
defg
abcdefg
efg
abceefg               //  !!!

ABCDEFG
abcdefg
BCDEFG
Bcdefg

***********
修改此帖时加此注：对于上面的问题，搞明白了，“=”的运算顺序是从左向右，不是从右向左，参见“《高质量C++/C编程指南》林锐 博士 2001”第4.1节，运算符的优先级，对于上面“!!!”部分我解释如下：编译器扫描*p=*++p的时候，首先扫描的是“=”左边的*p，此时指向ptr，继续扫描“=”号右边的表达式的时候，发现前++，此时给p进行++，再取*，而且"="左边的已经取值完毕，所以使得两边取值不同，他等同于*(n)=*(n+1)。个人理解，请指点。

关于下面的assert还是不明白，为什么断言失败？哪位能解释一下？谢了。
***********


上面提到的assert，经查assert.h中有如下定义：

1. extern void __assert (const char *__assertion, const char *__file, int __line)
   
2.      __THROW __attribute__ ((__noreturn__));
   
3. 
   
4. 
   
5. #  define assert_perror(errnum) \
   
6.   (__ASSERT_VOID_CAST (!(errnum) ? 0 :                        \      
   
7.                (__assert_perror_fail ((errnum), __FILE__, __LINE__,   \
   
8.                           __ASSERT_FUNCTION), 0)))
   

复制代码

对于test3.c这个程序：

1. #include <assert.h>
   
2. #include <stdio.h>
   
3. 
   
4. int main()
   
5. {
   
6.     int i=3;
   
7.     assert(i++ == i);
   
8. }

复制代码

执行cpp test3.c后显示如下：

1. ......
   
2. int main()
   
3. {
   
4.         int i=3;
   
5.         ((void) ((i++ == i) ? 0 : (__assert_fail ("i++ == i", "test3.c", 7, ((const char *) 0)), 0)));
   
6. }

复制代码

即使是宏替换，也没有理由assert断言失败啊感觉。
真的头疼了......

syisyi

《高质量C++/C编程指南》林锐 博士 2001   第4.1节，运算符的优先级

1. 
   
2. 优先级        运算符        结合律
   
3. 以下从高到低排列
   
4. ( )  [ ]  ->  .                                        从左至右
   
5. !  ~  ++  --  （类型） sizeof +  -  *  &                        [b]从右至左[/b]
   
6. *  /  %                                                从左至右
   
7. +  -                                                从左至右
   
8. <<  >>                                                从左至右
   
9. <   <=   >  >=                                        从左至右
   
10. ==  !=                                                从左至右
    
11. &                                                从左至右
    
12. ^                                                从左至右
    
13. |                                                从左至右
    
14. &&                                                从左至右
    
15. ||                                                [b]从右至左[/b]
    
16. ?:                                                [b]从右至左[/b]
    
17. =  +=  -=  *=  /=  %=  &=  ^= |=  <<=  >>=                        从左至右
    

复制代码