|
78 | 78 | Объясните, что произойдет в следующих отрезках кода. |
79 | 79 | Также, запустите данный код, чтобы убедиться в правильности вашей логики. |
80 | 80 |
|
| 81 | +1. ```cpp |
| 82 | + int a = 5; |
| 83 | + std::cout << a << std::endl; |
| 84 | + ``` |
| 85 | + |
| 86 | +1. ```cpp |
| 87 | + int a = 5; |
| 88 | + int a = 6; |
| 89 | + std::cout << a << std::endl; |
| 90 | + ``` |
| 91 | + |
| 92 | + <details> |
| 93 | + <summary>Правильный ответ:</summary> |
| 94 | + |
| 95 | + Переопределять переменные с тем же именем нельзя. |
| 96 | + Можно перезаписывать значения в существующих переменных. |
| 97 | + </details> |
| 98 | + |
| 99 | + |
81 | 100 | 1. ```cpp |
82 | 101 | int a = 5; |
83 | 102 | int b = 6; |
|
290 | 309 | Объясните, что произойдет в следующих отрезках кода. |
291 | 310 | Также, запустите данный код, чтобы убедиться в правильности вашей логики. |
292 | 311 |
|
| 312 | +
|
293 | 313 | 1. ```cpp |
294 | 314 | int a = 5; |
295 | 315 | int* b = &a; |
296 | 316 | std::cout << b; |
297 | 317 | std::cout << std::endl; |
298 | 318 | ``` |
299 | 319 |
|
| 320 | + <details> |
| 321 | + <summary>Ответ:</summary> |
| 322 | + |
| 323 | + `int* b = &a` сохраняет в `b` адрес переменной `a`. |
| 324 | + Далее печатается *адрес*, сохраненный в `b`. |
| 325 | + Не значение по адресу из `b` (записали бы как `*b`), а адрес в `b`. |
| 326 | + </details> |
| 327 | + |
| 328 | +1. Допустимо ли подобное? |
| 329 | + ```cpp |
| 330 | + int a; |
| 331 | + int* b = &a; |
| 332 | + std::cout << b; |
| 333 | + std::cout << std::endl; |
| 334 | + ``` |
| 335 | + |
| 336 | + <details> |
| 337 | + <summary>Ответ:</summary> |
| 338 | + |
| 339 | + Можно брать адрес неинициализированной переменной. |
| 340 | + Напечатается как обычный адрес. |
| 341 | + |
| 342 | + Недопустимо было бы *считывать по* этому адресу. |
| 343 | + </details> |
| 344 | + |
300 | 345 | 2. ```cpp |
301 | 346 | int a = 5; |
302 | 347 | int b = *(&a); |
|
353 | 398 | Ошибка компиляции (см. видео про указатели) |
354 | 399 | </details> |
355 | 400 |
|
| 401 | +1. Будет ли в `b` и в `c` тот же адрес? |
| 402 | + ```cpp |
| 403 | + int a = 5; |
| 404 | + int b = &a; |
| 405 | + a = 6; |
| 406 | + int c = &a; |
| 407 | + ``` |
| 408 | + |
| 409 | + <details> |
| 410 | + <summary>Правильный ответ:</summary> |
| 411 | + |
| 412 | + Будет тот же адрес. |
| 413 | + |
| 414 | + Переменные *никогда не меняют свой адрес*. |
| 415 | + `a = 6` впишет 6 в уже имеющуюся ячейку памяти. |
| 416 | + Это не перенаправляет `a` в другую ячейку. |
| 417 | + |
| 418 | + `&a` берет адрес *ячейки* `a`, а не значения в ней. |
| 419 | + Он всегда будет давать тот же адрес, вне зависимости от того, |
| 420 | + какое значение сохранили в `a`. |
| 421 | + </details> |
| 422 | + |
| 423 | + |
356 | 424 | 6. ```cpp |
357 | 425 | int a = 5; |
358 | 426 | int* ap = &a; |
|
366 | 434 | std::cout << std::endl; |
367 | 435 | ``` |
368 | 436 |
|
| 437 | +1. Допустимо ли подобное? |
| 438 | + ```cpp |
| 439 | + int a; |
| 440 | + int* b = &a; |
| 441 | + *b = 5; |
| 442 | + std::cout << a; |
| 443 | + std::cout << std::endl; |
| 444 | + ``` |
| 445 | + |
| 446 | + <details> |
| 447 | + <summary>Ответ:</summary> |
| 448 | + |
| 449 | + Переменную можно *инициализировать* через указатель. |
| 450 | + Подобное допустимо. |
| 451 | + </details> |
| 452 | + |
369 | 453 | 7. ```cpp |
370 | 454 | int a = 5; |
371 | 455 |
|
|
0 commit comments