Уже и с ИИ пытался, и на ютабе смотрел.... Ничего не ясно.
Мб есть какая-то простая аналогия? Как эту шнягу воспринимать?
Есть у нас переменная, нахуй нам указатель, если уже есть, на что ссылаться?
>Есть у нас переменная, нахуй нам указатель, если уже есть, на что ссылаться?
Значение переменной в памяти, память по адресу, адрес есть указатель. Начни с Ассемблера, это база.
Ты тролляка чтоль? Что за глупость спрашиваешь.
Указатель - это переменная типа "адрес". Она хранит в себе адрес памяти. Сделай
int *p;
sizeof(p);
У тебя покажет цифру 8. Потому что адреса обычно 8 байт, 0xffaabbcc.
p = &a
Соответственно присваиваешь адрес переменной "a" в переменную "p". Теперь если записать что-то по адресу который сохранен в "p", то будет у тебя это записано в переменную "а"
А. Спасибо.
Не. Я не троль. Просто впервые столкнулся с такой штукой.
Ну блин, ты бы почитал книг по синтаксису С перед тем как программировать. А то тут много чего есть с чем впервые столкнёшься.
Ууу бля! Какая же тебя веселуха ждёт когда столкнёшься с указателями на указатели, указателями на многомерные массивы, указателями на функции, указателями на указатели указателей...
>Есть у нас переменная, нахуй нам указатель, если уже есть, на что ссылаться?
1) В С передача аргументов функций идет по значению. Например у тебя есть функция
int add(int x, int y) { return x + y }
пусть у тебя есть переменные в основной программе a, b, когда ты вызовешь
int c = add(a,b), то программа, перейдя к телу функции, создаст локальные переменные x,y и загрузит в них значение из a,b. То есть функция выглядит на самом деле примерно так
int add( FIRST, SECOND ) { int x = FIRST; int y = SECOND; return x + y }
она твои оригинальные переменные не трогает, лишь копирует значение из них.
Тем самым передавая переменные в функцию, ты создаешь их копии! И тут есть несколько проблем
i) Представь у тебя есть жирная структура, передавая её в функцию, тебе придется копировать кучу данных, что трудозатратно.
ii) Представь ты хочешь написать функцию, которая должна менять переданную переменную. И ты не можешь это сделать, потому что все действия с переменной внутри функции происходят с её копией.
Поэтому используют указатели. Представь есть функция
void swap( int x, int y ), она должна поменять значения в x, y местами.
Передав в неё a, b, ты сделаешь их копии, и поменяешь значения в копиях, не то что тебе нужно. Но если
void swap (int x, int y) и ты вызовешь swap(&a, &b) в мейн программе
то функция сделает копии указателей. Но эти копии всё так же указывают на оригинальные a, b, и поэтому ты можешь влиять на них находясь внутри функции!
В общем, если у тебя есть переменная A, и ты хочешь поменять её внутри функции, тебе нужно, тчобы функция принимала указатель на А. Пусть например у тебя есть строка char a, ты хочешь указатель на начало строки поменять внутри функции, тогда ты в функую должен передать указатель (начало строки) = указатель (указатель a), получается знаменитый указатель на указатель.
Так же указатели решають проблему i), передав вместо структуры указатель на неё, у тебя скопируется не вся структура, а лишь указатель на неё, который меньше самой структуры в десятки раз.
2) Когда ты хочешь сделать что-то динамическое. Представь ты хочешь сделать датабазу, которая может расти/уменьшаться, пользователь может в неё добавлять значения во время работы программы.
Ты очевидно объявишь массив, типа int a[100]. Но тут будет проблема, что ты заранее не знаешь, какого размера у тебя должна быть база. Объявишь много, большая часть будет пустая. Объявишь мало, не влезит информация. Тебе нужно динамически, во время работы программы, создавать переменные. Тебе нужно написать функцию, "создающую" переменные.
Ты можешь написать функцию, выдающую числа int getNum() { return rand() }, аналогично ты можешь написать функцию, выдающую поинтеры int getP() { return (int*)malloc(sizeof int) }, malloc у ос просит отдать кусок памяти величиной под один int, и возвращает указатель на начало блока в деталях не совсем так, но не важно. И в этот блок ты можешь записать своё число. Вуаля, ты научился создавать переменные динамически. В твоей основной программе может быть вечный цикл, читающий ввод, и если вводишь 'add' он вызывает getP() и создает переменную во время работы программы, в сурс коде её не было.
Забыл что звездочки за разметку отвечают.
>void swap (int ✨x, int ✨y) и ты вызовешь swap(&a, &b) в мейн программе
>выдающую поинтеры int✨ getP() { return (int✨)malloc(sizeof int) }
Хуя се как гидно, я другой аноний, Си мне не нужен, я вкатун в пи эйч пи и жабовый скрипт. Но в МухГУ на первом курсе проходили основы Си. Я уже забыл про то, что такое указатели. Тут прочитал и ад вспомнил прослезился.
Указатель это просто циферки, буквально. Говорит что вот тут лежит хуйня которую следует считать такого типа, мамой клянусь.
Иди нахуй, неуч. Я написал это только чтобы макнуть тебя в унитаз ментально.
Не за что. Правда часть про динамическое выделение памяти я хуего написал, да и про передачу аргументов всратовато.
Сейчас бы дописал небольшой экскурс в историю, что раньше можно было писать куда угодно, но можно было бы случайно перезаписать важное. Тогда память стали разбивать на блоки, чтобы такого не случилось. А позже начали эту работу автоматизировать, так появились менеджеры-памяти, которые затем мутировали в ОС. И прося память у ОС, она, очевидно, не может выдать ничего, кроме адреса начала блока.
Крч, если коротко: ты либо относишься к категории людей, которая понимает указателиk либо ты их никогда в жизни не поймешь
Для этого заходишь на сайт Андрея Столярова http://stolyarov.info/books и открываешь 2 книги (Не обязательно их все читать!!!):
1) Программирование: введение в профессию. Том 1: азы программирования - http://www.stolyarov.info/books/pdf/progintro_vol1.pdf
2) Программирование: введение в профессию. II: низкоуровневое программирование - http://www.stolyarov.info/books/pdf/progintro_vol2.pdf
В первой книге открываешь страницу 350 и читаешь главу "2.13 Адреса, указатели и динамеческая память". В этой книге он рассказывает про указатели на примере Паксаля(он тебе нахуй не нужен, тебе нужно понять суть указатель на более простом языке!!!)
Во второй книге открываешь стр 251 и читаешь главу "4.4 Указатели, массивы, строки" и ещё стр 393 главу "4.13 Ещё об указателях". Тут уже идет C и подробное описание всего устройства этой хуйни(указателя)
Без рофлов - это буквально самый подробный способ понять что это за хуйня, как она работает и как её юзать даже не думая о том что это такое.
Если, перечитав все 3 главы по 5 раз и попрактиковавшись с кодом, и чатомГПТ, ты нихуя не понял - то буквально сдайся (Я НЕ ШУЧУ). Это криптонит, который ты и другие челы не смогут никогда понять, или смогут лишь понимать, как это работает на уровне тупого заучивания, а не осмыслено и без задней мысли юзать, когда надо
Можешь смотреть заумные книжки, а можешь поискать четырехкнижник Полякова по языку c. Там очень просто все даётся. Суммарно там не больше 220 страниц.
Чтобы понять указатели, надо представлять себе как работает компьютер. Что все данные, которыми оперирует процессор должны располагаться в ОЗУ. И причём эти данные лежат по каким-то конкретным адресам адресного пространства.
Ну и значит, раз есть адреса - можно значения этих адресов тоже сохранять где-то в памяти. Эти значения тоже будут данными. Которые зовутся указателями.
Длина указателя аппаратно зависима. В современных процессорах x86 в 64-битном режиме - очевидно 8 байт.
x86 в 32-битном режиме оперировали 4-байтными указателями.
В Z80, когда размер адресного пространства всего лишь 64 КБ, длина указателя 2 байта.
Под x86, DOS программы оперировали в сегментированном адресном пространстве, где длина сегмента 64 КБ, но сегменты могли различаться, перекрывали друг друга. И поэтому DOS программы различали "простые" 16-битные указатели и FAR указатели, размером 32 бита. Насколько помню, в FAR указателях хранился ещё и код сегмента, помимо смещения в самом сегменте.
И значит, дескрипторы сегментов под x86 в 16-битном реальном режиме процессора хранились в регистрах CS, DS, SS и иже с ними. Чтобы обратиться к адресу в другом сегменте нужно было сменить содержимое этого регистра, а только потом лезть по нужному адресу.
Пусть он попрограммирует под DOS с этой чехардой FAR и простых указателей. Или под Windows 3.11
Напоминаю, что DOS программы по-дефолту обитали именно в 16-битном реальном режиме x86 процессора. И именно в реальном режиме все x86 процессоры начинают свою работу при включении или reset-е.
>x86 в 32-битном режиме оперировали 4-байтными указателями.
x86 процессоры обрели 64-битный режим только в 2004 году, с выходом AMD Athlon 64 ЕМНИП. До этого, начиная с 80386, выпущенного в 1985 году (кажется), x86 максимум поддерживали 32-битный режим работы. В т.ч. Intel Pentium-ы 1, 2, 3.