字符串字面值的问题

delimy

1. in C++, a string literal has type "const char[]" with static storage duration
但是
const char str[] = "asdfasdf";
char *p = str;
会有错，而
char *p2 = "asdfasdf";
则可以编译，尽管修改p2会段错误。why?

2. in C, a string literal has type " char[]" with static storage duration
那么
{
char *p = "asdfasdf";
char *p2[] = "asdfasdf";
char *p3 = (char[]){"asdfasdf"};
}
都不同。第一个在栈上有一个指针，指向某个只读串（通常在只读页里的）。
第二个在栈上有个字符串，第三个在栈上有个指针指向栈上的一个字符串（无名的，可修改）。
那么对于后两种情形，是否一定有个static storage duration的只读串用于初始化栈呢？
或者说对于后两种情形，可否仅在函数里hard code这个串呢？毕竟那个string literal已经无法访问到了！

flw2

原帖由 delimy 于 2007-5-12 23:26 发表
1. in C++, a string literal has type "const char[]" with static storage duration
但是
const char str[] = "asdfasdf";
char *p = str;会有错，而
char *p2 = "asdfasdf";
则可以编译，尽管修改p2会段错误。why?
这个应该算是个例外，The c++上有说明。
2. in C, a string literal has type " char[]" with static storage duration
那么
{
char *p = "asdfasdf";
char *p2[] = "asdfasdf";
char *p3 = (char[]){"asdfasdf"};
}
都不同。第一个在栈上有一个指针，指向某个只读串（通常在只读页里的）。
第二个在栈上有个字符串，第三个在栈上有个指针指向栈上的一个字符串（无名的，可修改）。
那么对于后两种情形，是否一定有个static storage duration的只读串用于初始化栈呢？或者说对于后两种情形，可否仅在函数里hard code这个串呢？毕竟那个string literal已经无法访问到了！

要的，理由很简单，这个串的地址在栈中，要到运行时才知道地址，知道要放哪，也就是当前栈上。这需要一个显示的copy动作。

flw2

是否一定有个static storage duration的只读串用于初始化栈呢？

当然，还有一些体系结构没有栈，不过我不了解这个。

antigloss

原帖由 delimy 于 2007-5-12 23:26 发表
1. in C++, a string literal has type "const char[]" with static storage duration
但是
char *p2 = "asdfasdf";
则可以编译，

为了和旧代码兼容

MMMIX

1. 
   
2. char p[] = "abcd";
   
3. char *p1 = (char []){"abcd"};
   

复制代码

这两个定义其实是差不多的。如果它们在函数中出现，那么 p 和 p1 指向的地址都在栈上分配。

第二个定义的详情可参见 C99 6.5.2.5 Compound literals

langue

原帖由 MMMIX 于 2007-5-12 23:52 发表

1. 
   
2. char p[] = "abcd";
   
3. char *p1 = (char []){"abcd"};
   

复制代码

这两个定义其实是差不多的。如果它们在函数中出现，那么 p 和 p1 指向的地址都在栈上分配。

第二个定义的详情可参见 C99 6.5.2.5 Compound literals  

如果我指定 register 存储类呢？

.

antigloss

原帖由 langue 于 2007-5-13 08:52 发表


如果我指定 register 存储类呢？

.

那编译器可能将指针 p 和 p1 放到寄存器上，但 "abcd" 不会在寄存器上。

langue

原帖由 antigloss 于 2007-5-13 09:28 发表

那编译器可能将指针 p 和 p1 放到寄存器上，但 "abcd" 不会在寄存器上。

1. $ objdump -S register.o
   
2. 
   
3. register.o:     file format elf32-i386
   
4. 
   
5. Disassembly of section .text:
   
6. 
   
7. 00000000 <main>:
   
8. #include <stdio.h>
   
9. 
   
10. int
    
11. main()
    
12. {
    
13.    0:   55                      push   %ebp
    
14.    1:   89 e5                   mov    %esp,%ebp
    
15.    3:   83 ec 18                sub    $0x18,%esp
    
16.    6:   83 e4 f0                and    $0xfffffff0,%esp
    
17.    9:   b8 00 00 00 00          mov    $0x0,%eax
    
18.    e:   29 c4                   sub    %eax,%esp
    
19.   10:   a1 00 00 00 00          mov    0x0,%eax
    
20.   15:   89 45 e8                mov    %eax,0xffffffe8(%ebp)
    
21.     register char a[4] = {0, 1, 2, 3};
    
22.   18:   b8 00 00 00 00          mov    $0x0,%eax
    
23.   1d:   ba 01 00 00 00          mov    $0x1,%edx
    
24.   22:   88 d4                   mov    %dl,%ah
    
25.   24:   25 ff ff 00 ff          and    $0xff00ffff,%eax
    
26.   29:   0d 00 00 02 00          or     $0x20000,%eax
    
27.   2e:   25 ff ff ff 00          and    $0xffffff,%eax
    
28.   33:   0d 00 00 00 03          or     $0x3000000,%eax
    
29. 
    
30.     a[0]=0;
    
31.   38:   b0 00                   mov    $0x0,%al
    
32.     a[1]=1;
    
33.   3a:   ba 01 00 00 00          mov    $0x1,%edx
    
34.   3f:   88 d4                   mov    %dl,%ah
    
35.     a[2]=2;
    
36.   41:   25 ff ff 00 ff          and    $0xff00ffff,%eax
    
37.   46:   0d 00 00 02 00          or     $0x20000,%eax
    
38.     a[3]=3;
    
39.   4b:   25 ff ff ff 00          and    $0xffffff,%eax
    
40.   50:   0d 00 00 00 03          or     $0x3000000,%eax
    
41. 
    
42.     printf("%d\n%d\n%d\n%d\n", a[0], a[1], a[2], a[3]);
    
43.   55:   83 ec 0c                sub    $0xc,%esp
    
44.   58:   89 c2                   mov    %eax,%edx
    
45.   5a:   c1 fa 18                sar    $0x18,%edx
    
46.   5d:   0f be d2                movsbl %dl,%edx
    
47.   60:   52                      push   %edx
    
48.   61:   89 c2                   mov    %eax,%edx
    
49.   63:   c1 e2 08                shl    $0x8,%edx
    
50.   66:   c1 fa 18                sar    $0x18,%edx
    
51.   69:   0f be d2                movsbl %dl,%edx
    
52.   6c:   52                      push   %edx
    
53.   6d:   0f be d4                movsbl %ah,%edx
    
54.   70:   0f be d2                movsbl %dl,%edx
    
55.   73:   52                      push   %edx
    
56.   74:   0f be c0                movsbl %al,%eax
    
57.   77:   50                      push   %eax
    
58.   78:   68 00 00 00 00          push   $0x0
    
59.   7d:   e8 fc ff ff ff          call   7e <main+0x7e>
    
60.   82:   83 c4 20                add    $0x20,%esp
    
61. 
    
62.     return 0;
    
63.   85:   b8 00 00 00 00          mov    $0x0,%eax
    
64. }
    
65.   8a:   8b 55 e8                mov    0xffffffe8(%ebp),%edx
    
66.   8d:   3b 15 00 00 00 00       cmp    0x0,%edx
    
67.   93:   74 13                   je     a8 <main+0xa8>
    
68.   95:   83 ec 08                sub    $0x8,%esp
    
69.   98:   ff 75 e8                pushl  0xffffffe8(%ebp)
    
70.   9b:   68 0d 00 00 00          push   $0xd
    
71.   a0:   e8 fc ff ff ff          call   a1 <main+0xa1>
    
72.   a5:   83 c4 10                add    $0x10,%esp
    
73.   a8:   c9                      leave
    
74.   a9:   c3                      ret
    
75. $

复制代码

其实我不该拿汇编代码出来

.

delimy

原帖由 antigloss 于 2007-5-12 23:43 发表


为了和旧代码兼容

比较想知道这个兼容在C++标准哪一节规定的

delimy

原帖由 MMMIX 于 2007-5-12 23:52 发表

1. 
   
2. char p[] = "abcd";
   
3. char *p1 = (char []){"abcd"};
   

复制代码

这两个定义其实是差不多的。如果它们在函数中出现，那么 p 和 p1 指向的地址都在栈上分配。

第二个定义的详情可参 ...

不一样的吧。p是数组，不是指针。p在栈上分配，并且通过copy的方式初始化。
p1是指针，初始化为一个匿名物体（一个数组）的地址，那个匿名数组如上情形。
后一种在栈上多了个指针。