Указатели в с++ указывают только на адрес?

@Aqua77 · Регистрация: 13.07.2015

Студворк — интернет-сервис помощи студентам

Например указатель int *p; Он может инициализироваться только адресом?(и ничем другим) например *p=&s

shmkv · 28.08.2015, 00:56

Я вот понять не могу смысл спора: кто-то думает, что какой-то компилятор будет проверять указатель на 0 и обрабатывать как-то по-особому?

@Mr.X · 28.08.2015, 00:57

Сообщение от castaway

стандарт не идеален

Однако именно он служит критерием правильности компиляторов. Немножко странно с помощью кривоватого компилятора опровергать стандарт и Страуструпа. Хоть я и восхищаюсь вашей дерзостью.

Croessmah · 28.08.2015, 00:58

Сообщение от shmkv

кто-то думает

А по-моему, здесь вообще никто ничего не думает

shmkv · 28.08.2015, 01:00

Сообщение от Mr.X

Немножко странно с помощью кривоватого компилятора

Я вот хочу узнать название "не кривоватого" компилятора. И если он у меня есть, то не поленюсь выложить ассемблерный листинг аналогичного кода.

@castaway · 28.08.2015, 01:02

Croessmah, выхлоп IDA:

Кликните здесь для просмотра всего текста

Assembler
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
; Segment type: Pure code
; Segment permissions: Read/Execute
_text       segment dword public 'CODE' use32
        assume cs:_text
        assume es:nothing, ss:nothing, ds:_data, fs:nothing, gs:nothing
dword_0     dd 1BADB002h, 10001h, 0E4514FFDh, 2 dup(100000h), 2 dup(0)
                    ; DATA XREF: _start+90o
        dd offset _entry_point
; ---------------------------------------------------------------------------
 
_entry_point:               ; DATA XREF: .text:0000001Co
        mov esp, 200000h
        call    _start
; ---------------------------------------------------------------------------
 
loc_2A:                 ; CODE XREF: .text:loc_2Aj
        jmp short loc_2A
 
 
; _DWORD __cdecl print(int, int, char *)
        public __Z5printiiPc
__Z5printiiPc   proc near       ; CODE XREF: _start+5Fp _start+97p ...
 
arg_0       = dword ptr  8
arg_4       = dword ptr  0Ch
arg_8       = dword ptr  10h
 
        push    ebp
        mov ebp, esp
 
loc_2F:                 ; CODE XREF: print(int,int,char *)+3Bj
        mov eax, [ebp+arg_8]
        movzx   eax, byte ptr [eax]
        test    al, al
        jz  short loc_69
 
loc_39:                 ; DATA XREF: .eh_frame$_ZN1A3fooEv:00000284o
        mov edx, [ebp+arg_4]
        mov eax, edx
 
loc_3E:                 ; DATA XREF: .eh_frame:00000230o
        shl eax, 2
        add eax, edx
        shl eax, 4
        mov edx, eax
        mov eax, [ebp+arg_0]
        add eax, edx
        add eax, eax
        lea ecx, [eax+0B8000h]
        mov eax, [ebp+arg_8]
        lea edx, [eax+1]
        mov [ebp+arg_8], edx
        movzx   eax, byte ptr [eax]
        mov [ecx], al
        add [ebp+arg_0], 1
        jmp short loc_2F
; ---------------------------------------------------------------------------
 
loc_69:                 ; CODE XREF: print(int,int,char *)+Bj
        nop
        pop ebp
        retn
__Z5printiiPc   endp
 
 
; Attributes: noreturn bp-based frame
 
        public _start
_start      proc near       ; CODE XREF: .text:00000025p
                    ; DATA XREF: .eh_frame$_Z7str2hexIiEvPcT_:000002BCo
 
var_21      = byte ptr -21h
var_18      = dword ptr -18h
var_14      = dword ptr -14h
var_10      = dword ptr -10h
var_C       = dword ptr -0Ch
 
        push    ebp
        mov ebp, esp
        sub esp, 38h
        mov [ebp+var_C], 0B8000h
        mov [ebp+var_10], 7D0h
 
loc_80:                 ; CODE XREF: _start+2Cj
        cmp [ebp+var_10], 0
        js  short loc_9A
        mov eax, [ebp+var_C]
        lea edx, [eax+2]
        mov [ebp+var_C], edx
        mov word ptr [eax], 1F20h
        sub [ebp+var_10], 1
        jmp short loc_80
; ---------------------------------------------------------------------------
 
loc_9A:                 ; CODE XREF: _start+18j
        mov [ebp+var_14], 0 ; тут инициализируем указатель нулём
        mov eax, [ebp+var_14]
        mov eax, [eax]
        mov [esp+4], eax
        lea eax, [ebp+var_21]
 
loc_AD:                 ; DATA XREF: .eh_frame:00000250o
        mov [esp], eax
        call    __Z7str2hexIiEvPcT_ ; str2hex<int>(char *,int)
        lea eax, [ebp+var_21]
        mov [esp+8], eax    ; char *
        mov dword ptr [esp+4], 8 ; int
        mov dword ptr [esp], 0Ah ; int
        call    __Z5printiiPc   ; print(int,int,char *)
        mov eax, [ebp+var_14]
        mov dword ptr [eax], 12345678h
        mov eax, [ebp+var_14]
        mov eax, [eax]
        mov [esp+4], eax
        lea eax, [ebp+var_21]
        mov [esp], eax
        call    __Z7str2hexIiEvPcT_ ; str2hex<int>(char *,int)
        lea eax, [ebp+var_21]
        mov [esp+8], eax    ; char *
        mov dword ptr [esp+4], 9 ; int
        mov dword ptr [esp], (offset dword_0+0Ah) ; this
        call    __Z5printiiPc   ; print(int,int,char *)
        mov [ebp+var_18], 0
        mov eax, [ebp+var_18]
        mov ecx, eax
        call    __ZN1A3fooEv    ; A::foo(void)
 
loc_119:                ; CODE XREF: _start:loc_119j
        jmp short loc_119
_start      endp
 
; ---------------------------------------------------------------------------
unk_11B     db  90h ; Р        ; DATA XREF: .eh_frame:0000022Co
                    ; .eh_frame:0000024Co
_text       ends
 
; ===========================================================================
 
; Segment type: Zero-length
; Segment permissions: Read/Write
_data       segment dword public 'DATA' use32
_data       ends
 
; ===========================================================================
 
; Segment type: Zero-length
; Segment permissions: Read/Write
_bss        segment dword public 'BSS' use32
_bss        ends
 
; ===========================================================================
 
; Segment type: Pure code
; Segment permissions: Read/Execute
_text$_ZN1A3fooEv segment dword public 'CODE' use32
        assume cs:_text$_ZN1A3fooEv
        ;org 124h
; COMDAT (pick any)
        assume es:nothing, ss:nothing, ds:_data, fs:nothing, gs:nothing
 
; =============== S U B R O U T I N E =======================================
 
; Attributes: bp-based frame
 
; _DWORD A::foo(A *__hidden this)
        public __ZN1A3fooEv
__ZN1A3fooEv    proc near       ; CODE XREF: _start+A8p
 
var_14      = dword ptr -14h
var_9       = byte ptr -9
var_5       = dword ptr -5
var_1       = byte ptr -1
this        = dword ptr  8
 
        push    ebp
        mov ebp, esp
        sub esp, 20h
        mov [ebp+var_14], ecx
        mov dword ptr [ebp+var_9], 663A3A41h
        mov [ebp+var_5], 29286F6Fh
        mov [ebp+var_1], 0
        lea eax, [ebp+var_9]
        mov [esp+8], eax    ; char *
        mov dword ptr [esp+4], 0Ah ; int
        mov dword ptr [esp], 0Ah ; int
        call    __Z5printiiPc   ; print(int,int,char *)
        nop
        leave
        retn
__ZN1A3fooEv    endp
 
; ---------------------------------------------------------------------------
        db 2 dup(90h)
        db  90h ; Р        ; DATA XREF: .eh_frame$_ZN1A3fooEv:00000280o
_text$_ZN1A3fooEv ends
 
; ===========================================================================
 
; Segment type: Pure code
; Segment permissions: Read/Execute
_text$_Z7str2hexIiEvPcT_ segment dword public 'CODE' use32
        assume cs:_text$_Z7str2hexIiEvPcT_
        ;org 160h
; COMDAT (pick any)
        assume es:nothing, ss:nothing, ds:_data, fs:nothing, gs:nothing
 
; =============== S U B R O U T I N E =======================================
 
; Attributes: bp-based frame
 
; void str2hex<int>(char *, int)
        public __Z7str2hexIiEvPcT_
__Z7str2hexIiEvPcT_ proc near       ; CODE XREF: _start+44p _start+7Cp
 
var_15      = dword ptr -15h
var_11      = dword ptr -11h
var_D       = dword ptr -0Dh
var_9       = dword ptr -9
var_5       = byte ptr -5
var_4       = dword ptr -4
arg_0       = dword ptr  8
arg_4       = dword ptr  0Ch
 
        push    ebp
        mov ebp, esp
        sub esp, 20h
        mov [ebp+var_15], 33323130h
        mov [ebp+var_11], 37363534h
        mov [ebp+var_D], 62613938h
        mov [ebp+var_9], 66656463h
        mov [ebp+var_5], 0
        mov [ebp+var_4], 0
 
loc_18D:                ; CODE XREF: str2hex<int>(char *,int)+5Cj
        mov eax, 8
        cmp eax, [ebp+var_4]
        jbe short loc_1BE
        mov eax, 8
        sub eax, [ebp+var_4]
        lea edx, [eax-1]
        mov eax, [ebp+arg_0]
        add edx, eax
        mov eax, [ebp+arg_4]
        and eax, 0Fh
        movzx   eax, byte ptr [ebp+eax+var_15]
        mov [edx], al
        sar [ebp+arg_4], 4
        add [ebp+var_4], 1
        jmp short loc_18D
; ---------------------------------------------------------------------------
 
loc_1BE:                ; CODE XREF: str2hex<int>(char *,int)+35j
        mov edx, [ebp+arg_0]
        mov eax, [ebp+var_4]
        add eax, edx
        mov byte ptr [eax], 0
        nop
        leave
 
locret_1CB:             ; DATA XREF: .eh_frame$_Z7str2hexIiEvPcT_:000002B8o
        retn
__Z7str2hexIiEvPcT_ endp
 
_text$_Z7str2hexIiEvPcT_ ends
 
; ===========================================================================
 
; Segment type: Pure data
; Segment permissions: Read
_rdata$zzz  segment dword public 'DATA' use32
        assume cs:_rdata$zzz
        ;org 1CCh
aGccI686PosixDw db 'GCC: (i686-posix-dwarf-rev0, Built by MinGW-W64 project) 5.1.0',0
        align 4
_rdata$zzz  ends
 
; ===========================================================================
 
; Segment type: Pure data
................................................
        end

Выхлоп objdump:

Кликните здесь для просмотра всего текста

Assembler
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

main.o:     file format pe-i386
 
 
Disassembly of section .text:
 
00000000 <.text>:
   0:   02 b0 ad 1b 01 00       add    dh,BYTE PTR [eax+0x11bad]
   6:   01 00                   add    DWORD PTR [eax],eax
   8:   fd                      std    
   9:   4f                      dec    edi
   a:   51                      push   ecx
   b:   e4 00                   in     al,0x0
   d:   00 10                   add    BYTE PTR [eax],dl
   f:   00 00                   add    BYTE PTR [eax],al
  11:   00 10                   add    BYTE PTR [eax],dl
    ...
  1b:   00 20                   add    BYTE PTR [eax],ah
  1d:   00 00                   add    BYTE PTR [eax],al
    ...
 
00000020 <_entry_point>:
  20:   bc 00 00 20 00          mov    esp,0x200000
  25:   e8 42 00 00 00          call   6c <_start>
  2a:   eb fe                   jmp    2a <_entry_point+0xa>
 
0000002c <__Z5printiiPc>:
  2c:   55                      push   ebp
  2d:   89 e5                   mov    ebp,esp
  2f:   8b 45 10                mov    eax,DWORD PTR [ebp+0x10]
  32:   0f b6 00                movzx  eax,BYTE PTR [eax]
  35:   84 c0                   test   al,al
  37:   74 30                   je     69 <__Z5printiiPc+0x3d>
  39:   8b 55 0c                mov    edx,DWORD PTR [ebp+0xc]
  3c:   89 d0                   mov    eax,edx
  3e:   c1 e0 02                shl    eax,0x2
  41:   01 d0                   add    eax,edx
  43:   c1 e0 04                shl    eax,0x4
  46:   89 c2                   mov    edx,eax
  48:   8b 45 08                mov    eax,DWORD PTR [ebp+0x8]
  4b:   01 d0                   add    eax,edx
  4d:   01 c0                   add    eax,eax
  4f:   8d 88 00 80 0b 00       lea    ecx,[eax+0xb8000]
  55:   8b 45 10                mov    eax,DWORD PTR [ebp+0x10]
  58:   8d 50 01                lea    edx,[eax+0x1]
  5b:   89 55 10                mov    DWORD PTR [ebp+0x10],edx
  5e:   0f b6 00                movzx  eax,BYTE PTR [eax]
  61:   88 01                   mov    BYTE PTR [ecx],al
  63:   83 45 08 01             add    DWORD PTR [ebp+0x8],0x1
  67:   eb c6                   jmp    2f <__Z5printiiPc+0x3>
  69:   90                      nop
  6a:   5d                      pop    ebp
  6b:   c3                      ret    
 
0000006c <_start>:
  6c:   55                      push   ebp
  6d:   89 e5                   mov    ebp,esp
  6f:   83 ec 38                sub    esp,0x38
  72:   c7 45 f4 00 80 0b 00    mov    DWORD PTR [ebp-0xc],0xb8000
  79:   c7 45 f0 d0 07 00 00    mov    DWORD PTR [ebp-0x10],0x7d0
  80:   83 7d f0 00             cmp    DWORD PTR [ebp-0x10],0x0
  84:   78 14                   js     9a <_start+0x2e>
  86:   8b 45 f4                mov    eax,DWORD PTR [ebp-0xc]
  89:   8d 50 02                lea    edx,[eax+0x2]
  8c:   89 55 f4                mov    DWORD PTR [ebp-0xc],edx
  8f:   66 c7 00 20 1f          mov    WORD PTR [eax],0x1f20
  94:   83 6d f0 01             sub    DWORD PTR [ebp-0x10],0x1
  98:   eb e6                   jmp    80 <_start+0x14>
  9a:   c7 45 ec 00 00 00 00    mov    DWORD PTR [ebp-0x14],0x0
  a1:   8b 45 ec                mov    eax,DWORD PTR [ebp-0x14]
  a4:   8b 00                   mov    eax,DWORD PTR [eax]
  a6:   89 44 24 04             mov    DWORD PTR [esp+0x4],eax
  aa:   8d 45 df                lea    eax,[ebp-0x21]
  ad:   89 04 24                mov    DWORD PTR [esp],eax
  b0:   e8 00 00 00 00          call   b5 <_start+0x49>
  b5:   8d 45 df                lea    eax,[ebp-0x21]
  b8:   89 44 24 08             mov    DWORD PTR [esp+0x8],eax
  bc:   c7 44 24 04 08 00 00    mov    DWORD PTR [esp+0x4],0x8
  c3:   00 
  c4:   c7 04 24 0a 00 00 00    mov    DWORD PTR [esp],0xa
  cb:   e8 5c ff ff ff          call   2c <__Z5printiiPc>
  d0:   8b 45 ec                mov    eax,DWORD PTR [ebp-0x14]
  d3:   c7 00 78 56 34 12       mov    DWORD PTR [eax],0x12345678
  d9:   8b 45 ec                mov    eax,DWORD PTR [ebp-0x14]
  dc:   8b 00                   mov    eax,DWORD PTR [eax]
  de:   89 44 24 04             mov    DWORD PTR [esp+0x4],eax
  e2:   8d 45 df                lea    eax,[ebp-0x21]
  e5:   89 04 24                mov    DWORD PTR [esp],eax
  e8:   e8 00 00 00 00          call   ed <_start+0x81>
  ed:   8d 45 df                lea    eax,[ebp-0x21]
  f0:   89 44 24 08             mov    DWORD PTR [esp+0x8],eax
  f4:   c7 44 24 04 09 00 00    mov    DWORD PTR [esp+0x4],0x9
  fb:   00 
  fc:   c7 04 24 0a 00 00 00    mov    DWORD PTR [esp],0xa
 103:   e8 24 ff ff ff          call   2c <__Z5printiiPc>
 108:   c7 45 e8 00 00 00 00    mov    DWORD PTR [ebp-0x18],0x0
 10f:   8b 45 e8                mov    eax,DWORD PTR [ebp-0x18]
 112:   89 c1                   mov    ecx,eax
 114:   e8 00 00 00 00          call   119 <_start+0xad>
 119:   eb fe                   jmp    119 <_start+0xad>
 11b:   90                      nop
 
Disassembly of section .text$_ZN1A3fooEv:
 
00000000 <__ZN1A3fooEv>:
   0:   55                      push   ebp
   1:   89 e5                   mov    ebp,esp
   3:   83 ec 20                sub    esp,0x20
   6:   89 4d ec                mov    DWORD PTR [ebp-0x14],ecx
   9:   c7 45 f7 41 3a 3a 66    mov    DWORD PTR [ebp-0x9],0x663a3a41
  10:   c7 45 fb 6f 6f 28 29    mov    DWORD PTR [ebp-0x5],0x29286f6f
  17:   c6 45 ff 00             mov    BYTE PTR [ebp-0x1],0x0
  1b:   8d 45 f7                lea    eax,[ebp-0x9]
  1e:   89 44 24 08             mov    DWORD PTR [esp+0x8],eax
  22:   c7 44 24 04 0a 00 00    mov    DWORD PTR [esp+0x4],0xa
  29:   00 
  2a:   c7 04 24 0a 00 00 00    mov    DWORD PTR [esp],0xa
  31:   e8 2c 00 00 00          call   62 <__Z5printiiPc+0x36>
  36:   90                      nop
  37:   c9                      leave  
  38:   c3                      ret    
  39:   90                      nop
  3a:   90                      nop
  3b:   90                      nop
 
Disassembly of section .text$_Z7str2hexIiEvPcT_:
 
00000000 <__Z7str2hexIiEvPcT_>:
   0:   55                      push   ebp
   1:   89 e5                   mov    ebp,esp
   3:   83 ec 20                sub    esp,0x20
   6:   c7 45 eb 30 31 32 33    mov    DWORD PTR [ebp-0x15],0x33323130
   d:   c7 45 ef 34 35 36 37    mov    DWORD PTR [ebp-0x11],0x37363534
  14:   c7 45 f3 38 39 61 62    mov    DWORD PTR [ebp-0xd],0x62613938
  1b:   c7 45 f7 63 64 65 66    mov    DWORD PTR [ebp-0x9],0x66656463
  22:   c6 45 fb 00             mov    BYTE PTR [ebp-0x5],0x0
  26:   c7 45 fc 00 00 00 00    mov    DWORD PTR [ebp-0x4],0x0
  2d:   b8 08 00 00 00          mov    eax,0x8
  32:   3b 45 fc                cmp    eax,DWORD PTR [ebp-0x4]
  35:   76 27                   jbe    5e <__Z7str2hexIiEvPcT_+0x5e>
  37:   b8 08 00 00 00          mov    eax,0x8
  3c:   2b 45 fc                sub    eax,DWORD PTR [ebp-0x4]
  3f:   8d 50 ff                lea    edx,[eax-0x1]
  42:   8b 45 08                mov    eax,DWORD PTR [ebp+0x8]
  45:   01 c2                   add    edx,eax
  47:   8b 45 0c                mov    eax,DWORD PTR [ebp+0xc]
  4a:   83 e0 0f                and    eax,0xf
  4d:   0f b6 44 05 eb          movzx  eax,BYTE PTR [ebp+eax*1-0x15]
  52:   88 02                   mov    BYTE PTR [edx],al
  54:   c1 7d 0c 04             sar    DWORD PTR [ebp+0xc],0x4
  58:   83 45 fc 01             add    DWORD PTR [ebp-0x4],0x1
  5c:   eb cf                   jmp    2d <__Z7str2hexIiEvPcT_+0x2d>
  5e:   8b 55 08                mov    edx,DWORD PTR [ebp+0x8]
  61:   8b 45 fc                mov    eax,DWORD PTR [ebp-0x4]
  64:   01 d0                   add    eax,edx
  66:   c6 00 00                mov    BYTE PTR [eax],0x0
  69:   90                      nop
  6a:   c9                      leave  
  6b:   c3                      ret

@castaway · 28.08.2015, 01:09

Сообщение от Mr.X

Хоть я и восхищаюсь вашей дерзостью.

Спасибо. Мне это лестно. Правда.

shmkv · 28.08.2015, 01:16

А вообще я не согласен с высказыванием Mr.X, что пример castaway указывает на кривость компилятора по стандарту. В стандарте явно прописано, что компилятор не должен генерировать код обращения к 0му адресу по 0му указателю?

@castaway · 28.08.2015, 01:23

Mr.X, можешь назвать компилятор, который при разыменовании нулевого указателя будет выдавать предупреждение или ошибку?

@Mr.X · 28.08.2015, 01:25

Сообщение от castaway

Mr.X, можешь назвать компилятор, который при разыменовании нулевого указателя будет выдавать предупреждение или ошибку?

Ну, моя студия 2010 исключение выбрасывает.

@castaway · 28.08.2015, 01:32

Сообщение от Mr.X

Ну, моя студия 2010 исключение выбрасывает.

Ты говоришь про runtime, когда код уже скомпилирован.
Мой GCC тоже что-то бросит в рантайме под виндой.
Ты же не считаешь, что компилятор обязан контролировать разименование нулевого указателя в compile-time согласно Стандарта?

@AncientPenguin · 28.08.2015, 02:41

Сообщение от castaway

Это тебе не черная дыра.

Она никуда не указывает. Это просто большая урна с измельченным мусором.

Сообщение от castaway

Он в любом случае указывает на какие-то данные, о существовании которых ты можешь и не знать.

Да физически в указателе будет число которое является адресом пусть и некорректным, но логически если он равен nullptr с точки зрения программы там пусто, да на самом деле там не пусто, но это потому что пусто туда не положить.

Вопрос, при условии что 0 и nullptr это разные вещи (nullptr это вообще не число), куда указывает указатель nullptr? Второй вопрос, как положить в переменную указатель пусто не используя число-маркер?

@castaway · 28.08.2015, 02:53

Сообщение от AncientPenguin

при условии что 0 и nullptr это разные вещи

Это 0 в любом представлении. Я не могу представить ситуацию которую ты описал.

Сообщение от AncientPenguin

как положить в переменную указатель пусто не используя число-маркер?

Для меня не существует понятия "пусто" в виде указателя.

@AncientPenguin · 28.08.2015, 03:37

Сообщение от castaway

Для меня не существует понятия "пусто" в виде указателя.

А оно есть - nullptr.

Сообщение от castaway

Это 0 в любом представлении. Я не могу представить ситуацию которую ты описал.

Пишешь под одну ОС где 0 - невалидный указатель и nullptr = 0. компилируешь под другую ОС где 0 вполне обычный адрес, а невалидный допустим 666, поменял константу и в логике работы программы ничего не поменялось. Следовательно сама цифра 0 никак не относится к nullptr, это просто способ этот nullptr выразить (что-то вроде enum).

Если бы он указывал на пустой объект то:
Car *car = nullptr;
Tank *tank = nullptr;
Как два объекта разных типов (пусть и пустых, тип то указан) лежат по одному адресу? А вот если принять что и там и там пусто то все логично.

@Praktolock · 28.08.2015, 03:38

Сообщение от Mr.X

Ну, моя студия 2010 исключение выбрасывает.

Наверное не из-за нулевости указателя он это делает, а потому что к странице памяти левой обращяешся

@castaway · 28.08.2015, 03:53

Сообщение от AncientPenguin

А оно есть - nullptr.

Его нет. Это объясняется всего лишь отсутствием понимания с твоей стороны.

Сообщение от AncientPenguin

Следовательно

Не следовательно. Откуда ты берёшь эти следствия?

Сообщение от AncientPenguin

Если бы он указывал на пустой объект то:
Car *car = nullptr;
Tank *tank = nullptr;
Как два объекта разных типов (пусть и пустых, тип то указан) лежат по одному адресу? А вот если принять что и там и там пусто то все логично.

Учи язык с архитектурой, иначе за такие глупости я начну ставить плохие отзывы.

AncientPenguin, ты не понимаешь о чём говоришь. Не надо продолжать.

@AncientPenguin · 28.08.2015, 04:33

Сообщение от castaway

Учи язык с архитектурой, иначе за такие глупости я начну ставить плохие отзывы.

Ну не надо мама, я так больше не буду.

Сообщение от castaway

AncientPenguin, ты не понимаешь о чём говоришь. Не надо продолжать.

Я так понимаю это все аргументы. И тебя не смущает что маркер null появился раньше чем C++ и есть не только в контексте указателей (например БД). Но это определенно 0 адрес.

Хотя куда мне холопу спорить с вашей светлостью...

@Mr.X · 28.08.2015, 07:08

Сообщение от castaway

Ты же не считаешь, что компилятор обязан контролировать разименование нулевого указателя в compile-time согласно Стандарта?

Ну, если по стандарту там неопределенное поведение, то компилятор может делать все что хочет, и ответственность полностью перекладывается на программиста. И некоторые, к сожалению, с ней не справились.

Добавлено через 9 минут

Сообщение от Croessmah

а по-моему, здесь вообще никто ничего не думает

Да не говорите! Какая-то "тема номер шесть" получилась. Я вначале вообще думал, что люди просто троллят и придуриваются. Кто бы мог подумать, что в теме указателей плавают и люди на вид довольно опытные.
Кстати, из тех, кто заявлял, что указатели на члены хранят адреса, по-моему еще и не все покаялись.
Так что всем срочно повторять указатели! Страуструпа на вас нет!

shmkv · 28.08.2015, 11:35

Сообщение от Mr.X

моя студия 2010 исключение выбрасывает.

Это не студия исключение выбрасывает, а винда ловит #PF от обращения по нулевому адресу.

Добавлено через 1 минуту

Сообщение от AncientPenguin

nullptr это вообще не число

А что? Что может храниться в указателе кроме числа?

Добавлено через 10 минут

Сообщение от AncientPenguin

компилируешь под другую ОС где 0 вполне обычный адрес, а невалидный допустим 666, поменял константу и в логике работы программы ничего не поменялось.

Интересная теория, вот только ты можешь привести хотя бы 1 компилятор под любую платформу, где это так?

Добавлено через 1 минуту

Сообщение от AncientPenguin

Если бы он указывал на пустой объект то:
Car *car = nullptr;
Tank *tank = nullptr;
Как два объекта разных типов (пусть и пустых, тип то указан) лежат по одному адресу? А вот если принять что и там и там пусто то все логично.

Это глупость.

Добавлено через 12 минут

Сообщение от Mr.X

Ну, если по стандарту там неопределенное поведение, то компилятор может делать все что хочет, и ответственность полностью перекладывается на программиста. И некоторые, к сожалению, с ней не справились.

Некоторые, к сожалению, не осилили изучить хотя бы 1 архитектуру. И если и говорить в этом случае про UB, то только в контексте, что стандарт никак не оговаривает, что произойдет от разыменования нулевого указателя на конкретной платформе, точно также как и от обращения по любому другому захардкордженному адресу. Не вижу никакой связи с реализацией компилятора.

Tulosba · 28.08.2015, 11:44

Сообщение от hoggy

разыменовывание нулевого указателя - есть UB.

Разыменовывание - это ещё не UB, а вот использование разыменованного результата уже как бы да.
Аналогичное поведение можно наблюдать с итератором, который возвращается std::end(): сравнивать текущий с ним можно, но разыменовывать такой итератор нельзя.

Сообщение от shmkv

допустим в стандарте явно прописано, что разыменование нулевого указателя - UB.

В Стандарте на этот счет на самом деле довольно мутно. Некоторые обсуждения по теме внесения правок в Стандарт тут.

Сообщение от shmkv

C++
1
2
int *p = 0; 
cout << (int)p;

- Здесь нет разыменовывания;
- К тому же возможна потеря данных, если sizeof(int)<sizeof(int*) (например на x64);
- Сишный каст будет интерпретирован как reinterpret_cast, что в итоге уже говорит о платформозависимости данного кода. Т.е. не UB, но непереносимо.

@ct0r · 28.08.2015, 11:46

Понаписали, аж лень читать

Как-нибудь потом.

Сообщение от shmkv

точно также как и от обращения по любому другому захардкордженному адресу

Осиль поиск по стандарту.

Indirection through an invalid pointer value and passing an invalid pointer value to a deallocation function have undefined behavior. Any other use of an invalid pointer value has implementation-defined behavior.

Новые блоги и статьи Все статьи Все блоги /
Про "Windows must die!" kumehtar 04.11.2026 Знаете, чет накатило. . . . Когда-то это было почти боевым кличем: мол, нормальный человек сидит на DOS, OS/ 2 или Linux, а вот это вот - Must Die. А теперь человек произносит «мастдай» с усмешкой - и. . .	Красочные поля с номером страницы svg+background-image russiannick 04.11.2026 Красочные поля с номером страницы не менее важны чем в эпоху бумажных книг. Посему спешу представить почтеннейшей публике этот важный инструмент который эти поля и формирует. В процессе разработки. . .	Вступаем в новую фазу генерации favicons, векторную. russiannick 02.11.2026 Теперь нет нужды скрывать что используется простой svg. Исходный код изображения помещаем в поле и жмем кнопку. Исходник преобразуется в вид корректный для помещения в favicon или в url(). Нажатие. . .	Генератор паролей (вариант №4) Maks 01.11.2026 После публикации 3-го варианта генератора паролей, разослал его своим коллегам (с целью оценки), в итоге были получены следующие рекомендации: 1. Вернуть возможность использования знаков \| 1 l I;. . .
Генератор паролей (вариант №3) Maks 30.10.2026 Финальная версия генератора паролей 1С. Доработка решения в этот раз коснулась только визуальной части, а именно, добавлен реквизит ДопПараметры (тип Булево), который скрывает/ отображает реквизиты:. . .	Магическое мышление и магия, современная наука не отличима от магии (говорит ИИ Джемени) zorxor 30.10.2026 Джемени, расскажи, пожалуйста, что такое магическое мышление, что такое магия, почему современная наука чем-то напоминает магию? Фраза «Любая достаточно развитая технология неотличима от магии». . .	За какое время ИИ может подобрать пароль по хешу (рассказывает Джемени ИИ) zorxor 30.10.2026 Расскажи, Джемени, если известен хэш МД5, например, за сколько ИИ сможет подобрать соответствующий пароль? Искусственный интеллект (ИИ) может подобрать простой или средний по сложности пароль по. . .	Кто убил Suno? Почему наше солнышко погасло? (диалог с ИИ Джемени) zorxor 30.10.2026 Как убивали Suno. Хронология. «Убийство» музыкальной нейросети Suno — это затяжной процесс, в котором технологический хайп стартапа разбился о жесткую реальность судебных исков от гигантов. . .

@Aqua77 25 / 25 / 19 Регистрация: 13.07.2015 Сообщений: 433

	Указатели в с++ указывают только на адрес? 25.08.2015, 23:39. Показов 13986. Ответов 213 Метки нет (Все метки) Например указатель int p; Он может инициализироваться только адресом?(и ничем другим) например p=&s 0

shmkv 1378 / 522 / 72 Регистрация: 21.07.2015 Сообщений: 1,308
	28.08.2015, 00:56
	Я вот понять не могу смысл спора: кто-то думает, что какой-то компилятор будет проверять указатель на 0 и обрабатывать как-то по-особому? 0

shmkv 1378 / 522 / 72 Регистрация: 21.07.2015 Сообщений: 1,308
	28.08.2015, 01:16
	А вообще я не согласен с высказыванием Mr.X, что пример castaway указывает на кривость компилятора по стандарту. В стандарте явно прописано, что компилятор не должен генерировать код обращения к 0му адресу по 0му указателю? 1

@castaway 4986 / 3093 / 456 Регистрация: 10.11.2010 Сообщений: 11,170 Записей в блоге: 10
	28.08.2015, 01:23
	Mr.X, можешь назвать компилятор, который при разыменовании нулевого указателя будет выдавать предупреждение или ошибку? 0