Читаю книгу

@koeltrad · Регистрация: 29.07.2019

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

Когда пишу, то что читаю, запоминаю лучше.

Читаю книгу Курс программирования на языке СИ. Сергей Фомин, Вадим Подбельский
Есть такое предложение там:
Идентификаторы могут иметь любую длину, но компилятор учитывает не более 31 символа от начала идентификатора. В некоторых
компиляторах это ограничение еще более жесткое, и учитываются
только первые 8 символов любого идентификатора. В этом случае
идентификаторы NUMBER_OF_ROOM и NUMBER_OF_TEST
в программе будут неразличимы.
-----------------------------------------------
Непонятно что они имеют в виду под идентификатором? Возможно имена присваеваемые переменным?
Эти имена присваемые переменным не могут превышать 31 символ?

@мама Стифлера · 20.08.2021, 20:19

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

Только когда понимание появится, лучше обратно "приклеить" звездочку к имени переменной во избежание путаницы при объявлении

Как раз так и делаю, так как полного понимания пока нет

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

Сообщение от Алексей1153

школы прилепливания звёздочки разные, но нужно помнить, что это часть типа

или разыминовывание указателя, поэтому и приклеиваю всегда к переменной

Алексей1153 · 20.08.2021, 20:34

мама Стифлера, разыменование - это оператор. Это не относится к объявлению переменной-указателя

Добавлено через 33 секунды
так же, как и взятие адреса

@мама Стифлера · 20.08.2021, 20:52

Сообщение от Алексей1153

разыменование - это оператор. Это не относится к объявлению переменной-указателя

Но тем не менее это все тот же символ - звездочка, вот поэтому и путаница. И кстати насчет int* a, b; - хороший пример привели. Чтоб не путаться, реально проще прилепить звездочку к переменной. Пусть даже по синтаксису это не правильно.

Алексей1153 · 20.08.2021, 20:56

Сообщение от мама Стифлера

хороший пример привели

нет, это плохой пример. Лучше так не писать и не путаться.
Или, давай, вообще всё в одну строчку писать

Сообщение от мама Стифлера

Но тем не менее это все тот же символ - звездочка

ну, ещё звёздочка может быть оператором умножения (бинарный оператор). Никто же не путается

в Си полно таких вещей ))

Croessmah · 20.08.2021, 21:12

Правильно как-то так:

C
1
2
3
4
5
6
7
int *a;
int* *b;
int** *c;
 
int *a;
int * *b;
int * * *c;

@мама Стифлера · 20.08.2021, 21:12

Это тяжело понять. То есть, когда просто объявляем указатель, то пишем так int* ptr;
А когда объявляем с инициализацией, нужно писать так int *ptr = &b;

Алексей1153 · 20.08.2021, 21:31

мама Стифлера, нет, в обоих случаях звёздочка логичнее смотрится прилепленной к типу

C
1
2
3
int*   a     ;//без инициализации
int**  b = &a;
int*** c = &b;

Добавлено через 4 минуты
мама Стифлера, может, вот так нагляднее будет

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdio.h>
 
int main()
{
    typedef int*   int_ptr;
    typedef int**  int_ptr_ptr;
    typedef int*** int_ptr_ptr_ptr;
    
    int             i = 1;
    int_ptr         a = &i;
    int_ptr_ptr     b = &a;
    int_ptr_ptr_ptr c = &b;    
 
    (*a)=7;//при разыменовании получили ссылку на i
    printf("%d",i);
 
    (**b)=8;
    printf("%d",i);
 
    (***c)=9;
    printf("%d",i);
 
    return 0;
}

789
Добавлено через 2 минуты
подправил

@мама Стифлера · 20.08.2021, 21:53

Алексей1153,

с typedef еще запутанней вышло, лучше уж так

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

C
1
2
3
4
    int             i = 1;
    int*            a = &i;
    int**           b = &a;
    int***          c = &b;

В общем вроде понял. Если указан тип переменной, то звезду всегда лепить сразу после типа. А если типа нет, тогда лепить перед переменной и это означает разыминовывание, или присвоение. Ну как то так наверно.

Алексей1153 · 20.08.2021, 22:04

Сообщение от мама Стифлера

Если указан тип переменной, то звезду всегда лепить сразу после типа. А если типа нет

нету там никаких "если" :

1)
синтаксис объявления указателя:
указуемый_тип* имя_указателя /*=инициализация*/;

2)
синтаксис применения оператора разыменования:

* имя_указателя или * выражение_возвращающее_адрес

------
это два разных и не связанных между собой события: объявление указателя и разыменование при работе с указателем

при разыменовании можно лепить пробелов сколько угодно - логически это не мешает(хотя и смотрится некрасиво). Это такой же унарный оператор, как

+    1; //унарный плюс

-  1; //унарный минус

а алиасом через typedef я всего лишь хотел подчеркнуть, что звёздочка - это часть типа указателя

@COKPOWEHEU · 21.08.2021, 00:16

Сообщение от Алексей1153

не надо ничего приклеивать обратно, звёздочка - это часть типа

Ну вы же сами видите, что нет.

Сообщение от Алексей1153

вот так же всё понятно и красиво:

Но так безусловно лучше:

C
1
2
int *a = 0;
int b = 0;

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

сплошь и рядом превращается в ассемблерный листинг

В ассемблерный листинг оно может разворачиваться в любой, это не имеет никакого отношения к синтаксису.

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

Но вроде мы от темы отвлеклись

Да. Вы хотели привести пример где используются правила Моргана.

Сообщение от Алексей1153

может, вот так нагляднее будет

Кошмар какой!

Сообщение от мама Стифлера

В общем вроде понял. Если указан тип переменной, то звезду всегда лепить сразу после типа.

Звезду почти всегда стоит лепить к переменной. Единственное исключение, которое я могу вспомнить - возвращаемое значение функцией, там переменной просто нет. Не к имени функции же лепить, можно с указателем на функцию спутать.

@TheCalligrapher · 21.08.2021, 03:55

Сообщение от Алексей1153

нет, в обоих случаях звёздочка логичнее смотрится прилепленной к типу

"Логичнее", "не логичнее"... это в любом случае попытки перекроить язык под себя. Это ничем принципиально не отличается от препроцессорной замены { и } , на begin и end, потому что кому-то так так "логичнее".

Во-первых, в семантике объявления языка С звездочка всегда жестко ассоциирована с объявляемым идентификатором, а не с именем типа.

Во-вторых, свое перекраивание вы сможете применить только к префиксным элементам объявления (звездочка), а с постфиксными ничего сделать все равно не сможете: сколько бы вы ни доказывали, что "логичнее" int[10] a, вам все равно придется писать int a[10].

Зачем в такой ситуации нужны эти вялые полумеры со звездочкой?

@koeltrad · 21.08.2021, 06:15 **[ТС]**

Вопрос серьёзнее чем я думал.
Придумал другую теорию.
Очень хорошее название: Ссылки. Но для красочности, наглядности и хорошего понимания я назвал это: Эффект Сабзиро(В игре мортал комбат Сабзиро оставляет своих ледяных клонов))) Или просто: Клоны.

Во первых, такой код работать не будет:
Пример без указателей:

C
1
2
3
4
5
6
7
8
#include<stdio.h>
int main() {
     int b;
     int a = b;
     b=20;
     printf("%d\n%d\n", b, a);
return 0;
}

В то время, когда приравниваем int a = b; переменная b равна нулю, поэтому и переменная а будет равняться нулю.

С указателями идёт телепортация значений, подставление(ссылка, пересылка).

C
1
2
3
4
5
6
7
8
#include<stdio.h>
int main() {
     int b;
     int *a = &b;
     b=20;
     printf("%d\n%d\n", b, *a);
return 0;
}

Здесь int *a = &b; *a и &b оставляют свои клоны ДЛЯ доставки в них ЗНАЧЕНИЙ, (точки телепортации, ссылки).
Причём адрес для доставки ЗНАЧЕНИЙ это *a и b (НЕ &b).
И теперь можно из любого места кода(с небольшими оговорками) приравнять значение *a чему либо или b чему либо и они оба будут иметь одно ЗНАЧЕНИЕ.

Например написали в любом месте кода(с небольшими оговорками) *а=20; Теперь значение 20 телепортируется в значение *а в этом выражении int *a = &b;
И переменная b тоже стала иметь такое же значение потому что *a = &b;
В таком выражении ЗНАЧЕНИЯ переменных приравниваются друг к другу по законам обыкновенного кода. Так как значения хранятся в *a и b, то *a=b
-----------------------------------
(Действия совершаются разные над *a и a, а название(Указатель) одно и то же у них, считаю что это непорядок. *a - это клон указателя для ЗНАЧЕНИЯ переменной, (точка телепорта для ЗНАЧЕНИЯ переменной, ссылка), а - это указатель, в ЗНАЧЕНИИ которого находится АДРЕС другой переменной).
Указателем обычно называют int *a; Моё мнение, что указатель это просто а, так как в ЗНАЧЕНИИ переменной а хранится АДРЕС другой переменной, а вот в *a хранится ЗНАЧЕНИЕ переменной, ссылка на которую содержится в указателе.
Считаю что в этом вся путаница и если это объяснить правильными терминами, то всё станет понятно, я как всегда по колхозному изложил.
Адрес в указателе сохраняется тоже в значении переменной, но без звёздочки.
Нда, видимо в моём тексте можно запутаться по этому поводу.
Я не утверждаю что я прав, исхожу из результатов опытов)

Добавлено через 13 минут
Насчёт того что адрес сохраняется в переменной не навсегда, спасибо.
Значение переменной сохраняется в *a и b. Адрес сохраняется в a и &b(&b- отсюда берётся адрес, а не сохраняется там).
Соответственно меняем адрес сохранённый в УКАЗАТЕЛЕ:
Этот адрес &b изменить не получится, а если получится, то виндовс покажет фигу и синий экран. Куда типа лезешь менять стандартные названия ячеек.

C
1
2
3
4
5
6
7
8
9
10
11
#include<stdio.h>
int main() {
     int c;
     c=10;
     int b;
     int *a = &b;
     b=20;
     a=&c;  
     printf("%d\n%d\n", *a, c);
return 0;
}

Можно обратить внимание на a=&c; Допустим а=5, &c=10. Но 5 не может равняться 10)) Поэтому можно догадаться что здесь идёт присвоение адреса от переменной &c УКАЗАТЕЛЮ на переменную b, который(указатель) находится в ЗНАЧЕНИИ переменной а.
Очень занимательный фокус Указателя заключается в том, что чей адрес содержит Указатель, значение той переменной принимает переменная Клон Указателя(*ссылка, переменная со звёздочкой).
Например если указатель а содержит адрес переменной &с, то ЗНАЧЕНИЕ *а будет равняться ЗНАЧЕНИЮ с. Адрес &с содержится в указателе а, поэтому а* принимает значение переменной с.
Пример:
*а=&b; b=20; а содержит адрес переменной b, поэтому ЗНАЧЕНИЕ *а равно ЗНАЧЕНИЮ b, то есть 20.
В этом примере можно догадаться об этом, но если вносить другие адреса переменных, то это знание помогает:

Дальше по коду случается апдейт. a=&c;
В переменной Указателе а содержался адрес переменной b, но мы присвоили в Указатель а адрес переменной с, поэтому теперь ЗНАЧЕНИЕ *а равняется ЗНАЧЕНИЮ переменной с. Что я и вывел на экран в коде.
a=&c; Это выражение по моему это в чистом виде указатель, так как переменная а содержит адрес на другую переменную и ничего лишнего.
Я этот текст сам медленно читаю чтоб понять только что написанное если что))) Сабзиро какой то в языке Си)) Я в шоке.

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

C
1
2
3
4
5
6
7
8
#include<stdio.h>
int main() {
     int b=20;
     int *a = &b;
     *a=10;
     printf("%d\n%d\n", *a, b);
return 0;
}

Если говорить только о значениях переменных(не затрагивая указатели), то Здесь int *a = &b; идёт ОБЫКНОВЕННЫЙ обмен ЗНАЧЕНИЯМИ переменных по обыкновенным законам кода. Главное понимать что значения переменных лежат в *a и b.
В данном примере *a=10; записан последним в коде, поэтому значение *a телепортируется в значение(ссылку *a) в этом коде int *a = &b; и значение а* стаёт равным значению b.

@sharpey · 21.08.2021, 08:20

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

почитай книгу Криса Касперски "Техника отладки программ без исходных кодов"

Мне ещё понравилась на английском "Malware Analysis: The Hands-On Guide to Dissecting Malicious Software" авторы которой Michael Sikorski (https://twitter.com/#!/mikesiko) и Andrew Honig, являются известными практиками в области анализа вредоносных программ.
В Сети нагуглить можно.

ValeryS · 21.08.2021, 09:20

koeltrad, теперь свои рассуждения изложи кратко

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

В то время, когда приравниваем int a = b; переменная b равна нулю, поэтому и переменная а будет равняться нулю.

если объявлена не глобальная, или статическая, переменная, то при объявлении без инициализации в ней может быть любое значение.

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

Да. Вы хотели привести пример где используются правила Моргана.

обнуление пятого и седьмого бита

C
1
a&=~(1<<5 | 1<<7);

Алексей1153 · 21.08.2021, 10:35

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

Но так безусловно лучше:
int *a = 0;
int b = 0;

конечно же нет

дополнение: конечно же, для компилятора глубоко по барабану на пробелы, и куда лепить звёздочку каждый делает по своему вкусу. Лично для меня удобнее совмещать звёздочку с типом.

кому-то вон и египетские скобки нравятся

@COKPOWEHEU · 21.08.2021, 10:55

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

обнуление пятого и седьмого бита

Это всего лишь сдвиги и наложение масок. Преобразований AND-OR-NOT там нет.

Сообщение от Алексей1153

конечно же нет

Конечно же, вы вправе ловить грабли на ровном месте. Я же предпочту писать так, чтобы неправильное написание и выглядело противоестесвенно. Ну как те же звездочки, прилепленные к типу. Осталось еще обратную нотацию сравнений освоить, но она при своей защите от ошибки = / == сама выглядит странно.

Сообщение от Алексей1153

кому-то вон и египетские скобки нравятся

Вы имеете в виду тот интуитивно понятный формат, где скобка остается на строке с условием или объявлением функции, а не выносится на отдельную строку? Действительно, странные люди, не желают заниматься мазохизмом.
Открывающая скобка это ведь невероятно важный символ, его обязательно надо вынести на отдельную строчку, да еще и отступ добавить. Чтобы тело условия ну никак нельзя было с условием связать. Ну и чтобы раздуть код в ширину и высоту - так он солиднее смотрится.

@koeltrad · 21.08.2021, 15:40 **[ТС]**

Чтоб кратко изложить мне надо ещё немного потренироваться.
Главная мысль в том что а и *а не одно и то же. а это указатель, *а это ссылка для значений.(хотя адрес тоже находится в значении переменной а, в переменной без звёздочки).
Вторая главная мысль в том что: int*a=&b; вместе с адресом переменной &b, в переменную *а качует значение переменной b.
Из &b в а переходит адрес, в *а переходит значение b. Значение может переходить в обратную сторону: из b в *а.

@TheCalligrapher · 21.08.2021, 18:38

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

Придумал другую теорию.

Зачем здесь придумывать какие-то "теории"?

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

Во первых, такой код работать не будет:

Что такое "работать не будет"?

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

В то время, когда приравниваем int a = b; переменная b равна нулю,

Нет. Переменная b не инициализирована. Никакому "нулю" она не равна.

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

С указателями идёт телепортация значений, подставление(ссылка, пересылка).

Дальше можно не читать... Скоро у нас появится Копенгагенская интерпретация работы с памятью, интерпретация Множества Миров...

@koeltrad · 21.08.2021, 21:52 **[ТС]**

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

Нет. Переменная b не инициализирована. Никакому "нулю" она не равна.

Такая же ситуация и в этом коде

C
1
2
3
4
5
6
7
#include<stdio.h>
int main() {
    int b;
    int *a =&b;
    printf("%d\n", *a);
return 0;
}

Здесь int *a =&b; значения у b ещё нет и идёт уравнивание значения *a =b
-----------------------
Версию со ссылками тем более никто не читал бы. Она скучнее. Телепортация- это я имел в виду сохранение значения переменной в нескольких местах одновременно.

Добавлено через 6 минут
А почему сохранение переменных во всех местах одновременно?
Потому что если снизу приписать b=20; то значение у переменной b ВЫШЕ по коду появится. ВЫШЕ, Карл))
С простыми переменными так не сработает.

C
1
2
3
4
5
6
7
8
#include<stdio.h>
int main() {
    int b;
    int *a =&b;
    b=20;
    printf("%d\n", *a);
return 0;
}

Или просто - Телепортация))

@мама Стифлера · 21.08.2021, 21:52

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

Телепортация- это я имел в виду сохранение значение переменной в нескольких местах одновременно

Не не верно. Значение переменной хранится только в одном месте - в ячейке памяти. А вот адрес памяти для этой ячейки, может хранится во многих переменных, которые будут являться указателями.

Новые блоги и статьи Все статьи Все блоги /
Рефакторинг программы уравнивания. Massaraksh7 26.05.2026 Пример по предыдущей записи в блоге. Но, надо заметить, что, во-первых, там оптимизация не только математики, но и работы с базой данных, и с графами, а во-вторых, это ещё не всё.	Использование TThread в Lazarus для математических вычислений. Massaraksh7 25.05.2026 Производя рефакторинг своих программ на предмет ускорения их работы, обратил внимание на такой аспект, как сокращение времени матвычислений. Дело в том, что приходится работать с большими матрицами. . .	Модель здравосохранения 18. Чем здоровее работник, тем быстрее выгорает anaschu 24.05.2026 Имитационная модель корпоративного здравоохранения: что показывает математика Сегодня в модели рабочего коллектива на AnyLogic появились три новые механики — выгорание через накопленную усталость,. . .	Модель здравосохранения 17. Планы на выгорание anaschu 23.05.2026 Вот конкретная схема реализации: В классе Работник добавить: накопленнаяУсталость — растёт каждый час работы, снижается в перерывы и болезни коэффициентПрезентеизма — снижает продуктивность. . .
Изменение цветов в палитре gif файла aka фавикона russiannick 23.05.2026 Изменение цветов в палитре gif файла, юзаемого как фавиконка в составе html-файла, помещенная в base64, средствами нативного Java Script, навеянное сном в майский день. Для работы необходим браузер,. . .	Модель здравосохранения 16. Слишком хорошие и здоровые сотрудники уходят, недовольные зарплатой anaschu 23.05.2026 Отладка увольнений и настройка производительности Сегодня во второй половине дня разобрались с механикой увольнений и настроили коэффициент сложности заданий. Вот что было сделано. . . .	Как я стал коммунистом))) Модель сохранения здоровья сотрудников, запись блога номер 15 anaschu 23.05.2026 Внезапно хорошее здоровье сотрудников не нужно капиталистам?))	Модель здравоСохранения 15. Как мы чинили AnyLogic модель рабочего коллектива: сочленение диаграммы состояний болезней и поломок в ресурспул anaschu 23.05.2026 Как мы чинили AnyLogic модель рабочего коллектива Сегодня разобрались с пятью багами, из-за которых модель либо падала с ошибкой, либо давала совершенно бессмысленные результаты. Каждый баг был. . .

@koeltrad 11 / 7 / 4 Регистрация: 29.07.2019 Сообщений: 701

	Читаю книгу 14.08.2021, 19:12. Показов 14213. Ответов 222 Метки нет (Все метки) Когда пишу, то что читаю, запоминаю лучше. Читаю книгу Курс программирования на языке СИ. Сергей Фомин, Вадим Подбельский Есть такое предложение там: Идентификаторы могут иметь любую длину, но компилятор учитывает не более 31 символа от начала идентификатора. В некоторых компиляторах это ограничение еще более жесткое, и учитываются только первые 8 символов любого идентификатора. В этом случае идентификаторы NUMBER_OF_ROOM и NUMBER_OF_TEST в программе будут неразличимы. ----------------------------------------------- Непонятно что они имеют в виду под идентификатором? Возможно имена присваеваемые переменным? Эти имена присваемые переменным не могут превышать 31 символ? 0

Алексей1153 фрилансер 6486 / 5713 / 1133 Регистрация: 11.10.2019 Сообщений: 15,232
	20.08.2021, 20:34
	мама Стифлера, разыменование - это оператор. Это не относится к объявлению переменной-указателя Добавлено через 33 секунды так же, как и взятие адреса 0

@мама Стифлера из племени тумба-юбма 2523 / 1819 / 419 Регистрация: 29.11.2015 Сообщений: 8,857 Записей в блоге: 15
	20.08.2021, 21:12
	Это тяжело понять. То есть, когда просто объявляем указатель, то пишем так `int* ptr;` А когда объявляем с инициализацией, нужно писать так `int *ptr = &b;` 0

@koeltrad 11 / 7 / 4 Регистрация: 29.07.2019 Сообщений: 701
	21.08.2021, 15:40 [ТС]
	Чтоб кратко изложить мне надо ещё немного потренироваться. Главная мысль в том что а и а не одно и то же. а это указатель, а это ссылка для значений.(хотя адрес тоже находится в значении переменной а, в переменной без звёздочки). Вторая главная мысль в том что: inta=&b; вместе с адресом переменной &b, в переменную а качует значение переменной b. Из &b в а переходит адрес, в а переходит значение b. Значение может переходить в обратную сторону: из b в а. 0