Для чего нужны указатели и как ими пользоваться? В каких случаях нужно их использовать, а в каких - нет?

P.S. Я этот вопрос задал не от того, что не искал. У меня есть учебник по C++, но там об этом ничего не написано.

Два указателя: на память(хранит адрес) и на значение. Нужны для того, чтобы указывать

Гениально. Я, разумеется, все понял.
А понормальней объяснить можно? Пример привести можете? (особенно желательно пример работы со строками с применением указателей).

Это сообщение отредактировал(а) sim7 - 2.8.2005, 16:37

В поиск батенька, в FAQ здешнее. Всё уже давно описано.

У меня почему-то FAQ вашего сайта не отображается. Я там пробовал лазить. У меня вообще нет списка статей и страниц... Пробовал разные браузеры, не могу зайти.

Пользоваться так:

Код

int a = 45; int *ptr = &a; // взять адресс (*ptr) += 5;   // получить из адресса a=50 cout << *ptr << endl;

Если указатель на начало массива:

Код

int *a = (int*)malloc(100); // выделение памяти под массив из 50 элементов for (int i=0; i<50; ++i)   a[i] = random(34); *(a+12) += 5; // обращение к 7-му элементу массива //..... free(a); // освобождение памяти

А можете привести пример работы со строками?

sim7
Указатель на что-то нужен чтобы с этим чем-то работать. Проход по массиву тебе уже показали, часто используются при работе с объектами, при передаче параметров по указателю и т.д., то есть чтобы не тратить лишнюю память. Учись дальше и все поймешь, твой вопрос из разряда "зачем нужны массивы"...

http://forum.vingrad.ru/index.php?showtopi...3;\.\.
Сомневаюсь, что поиск у вас тоже не работает.

Спасибо. Поиск работает.

Ну конечно всё что нельзя сделать без указателей можно сделать при помощи переменных ссылок. Кстати в дочернем языке от микрософт с# нет указателей.
Ну а так можно отметить что функция в языке с или с++ возвратить может только одну переменную и что делать если таких переменных две, три, пять... сто...? Правильно использовать указатели (ну или ссылки). А после выполнения функции использовать указатель как надо. вот пример:

Код

#include <iostream> using namespace std; int itos(int num, char * str); int main (void) {       int n=12345;       int c;       char * s = new char[10] ;       c=itos(n,s);       for(int i=0; i<=c; i++)       {                cout << s[i] << '\n';       }       delete s;       return 0; } int itos(int num, char * str) {       itoa(num,str,10);       return srlen(str); }

Кстати библиотека stl ох как не может существовать без указателей. Ведь итераторы в приметивном своём виде это и есть указатели (ну а не в приметивном классы )

Это сообщение отредактировал(а) CoreDumped - 3.8.2005, 08:07

Цитата(CoreDumped @ 2.8.2005, 18:18)

Кстати библиотека stl ох как не может существовать без указателей.

Ни одна серьёзная библиотека/программа/функция даже не может существовать без указателей.

Залезь в соседнюю тему, где чувак корячится с двухмерным массивом. Посмотри, как он обращается к элементам, и как я.

Если все еще остались темные пятна в использовании указателей, почитай мою, хм, "статью" тут. Писал я её давно. На тот момент у меня за плечами не было и полугода программирования. И поэтому сейчас можно очень много всего добавить и подправить. Об одних только указателях на функции-члены и приведении типов в стиле C++ можно столько понаписать.. Но тебе, как начинающему, хватит.

Цитата

если где соврал, не бейте сильно, а просто поправьте.

Chaos A.D., статья отличная, но есть парочка неточностей...

Цитата

Кстати, можно написать и так : int &r = 12; Тут не будет ошибки...

По Стандарту здесь ошибка. Все что ты расписал ниже(в статье) относится скорее к const int & r = 12;

Кстати тут мне вспомнился очень поучительный пример:

Код

const int ci = 7;  const int* pci = &ci; const int* &rpc = &ci;//выдает ошибку

,но

Код

const int ci = 7;  const int* pci = &ci; const int * const & rpc = &ci; //все ok

Цитата

const_cast – обеспечивает приведение типов, которое снимает или устанавливает константность у объекта. И не только константность...

ИМХО, только снимает, но не устанавливает константность.

Это сообщение отредактировал(а) LPBOY - 3.8.2005, 12:24

По поводу int &r = 12 - во времена написания статьи я пользовался только компилером Borland C++ 5.6, поэтому там оно работало. Естессно, что Borland-у до стандарта очень далеко...

На счет только снимает, но не устанавливает константность:

Eсли ты выполнишь

Код

const Foo *f = const_cast<const Foo*>(nonconst_foo);

где nonconst_foo - указатель на неконстантный Foo, получится, что хоть const из неconst-а получается автоматически, const_cast все же привел nonconst_foo к const Foo*. Это как в случае с implicit_cast, который не ввели в стандарт, потому что он реализовывался вручную и фактически ничего не делал, но вроде как приводил типы. Библии от страуструпа под рукой нет, так что некуда обратиться за истиной в последней инстанции.

Это сообщение отредактировал(а) Chaos A.D. - 3.8.2005, 14:17

Да, со вторым замечанием я видимо поспешил, сорри... Просто я о таком никогда не слышал.
Просмотрел несколько книг (в том числе Страуструпа) нигде не встретил упоминания, что const_cast может устанавливать константность (говорилось только о снятии константности), но и опровержения этому также не встретил... Но предназначение const_cast все-таки в снятии константности.

Это сообщение отредактировал(а) LPBOY - 3.8.2005, 15:48

Chaos A.D., статья, может быть, и хорошая, но я, к стыду своему, все равно ничего не понял...
Я одного не могу понять. Зачем программе работать с адресами переменных, а не с самими переменными (для этого ведь и существуют указатели и значки амперсанда, верно?). Кстати, еще непонятно, какая разница между указателями и "взятием адреса" через использование амперсанда (&)...

Цитата(LPBOY @ 3.8.2005, 10:08)

ИМХО, только снимает, но не устанавливает константность.

Цитата(Chaos @ 3.8.2005, 14:14)

Библии от страуструпа под рукой нет, так что некуда обратиться за истиной в последней инстанции.

В "библии" рыться не буду, уж больно толста , но вот MSDN говорит, что только снимает:

Цитата(MSDN)

The const_cast operator can be used to remove the const, volatile, and __unaligned attribute(s) from a class.

Хотя, видимо, написать приведение к не-конст-типу можно, но смысла большого в этом нет.

sim7, тебе нужен хороший учебник. ИМХО самый лучший учебник - учебник С. Липпмана.
Верней у него их даже два. Один - огромная книжка где почти весь С++ описан во всех подробностях и все хорошо разжевано. (В инете ее легко найти). Вторая книжка небольшая, но написана для совсем начинающих, в инете видел только на англ. яз. Хотя вот здесь http://forum.vingrad.ru/index.php?showtopic=33456 я видел несколько ссылок на нее, но насчет языка не знаю.

Цитата

В инете ее легко найти

А я что-то не нашел... Ее можно через инет скачать? Дайте ссылку, если можно... Прямую ссылку на файл, желательно.

http://anatolix.naumen.ru/files/books/lipp..._primer_rus.zip

Я ее грузил уже, оказывается... Там я еще больше ничего не понял, потому что там структура какая-то нездоровая. Начинает изучение языка с классов. Что-то у него там не то, там я еще больше не разобрался.
Может, дадите ссылку на учебник "стандартной" структуры (но для новичков, конечно)?

Читай с третей главы!!!

Понял, больше ссылок вы не знаете. Ладно, все равно спасибо.

Читай Дейтела.

Хм... Дейтела опустили вот тут вот...
http://accu.org/cgi-bin/accu/rvout.cgi?fro...&file=cp003204a

Я в английском ничего не понимаю, но надпись "Not Recommended" понятна вполне. Так стоит ли его (Дейтела) покупать, и какая самая лучшая книга по C++ от него?

В другом ревью оно highly recommended: http://accu.org/bookreviews/public/reviews/c/c002311.htm

Цитата(sim7 @ 3.8.2005, 21:00)

Я одного не могу понять. Зачем программе работать с адресами переменных, а не с самими переменными (для этого ведь и существуют указатели и значки амперсанда, верно?). Кстати, еще непонятно, какая разница между указателями и "взятием адреса" через использование амперсанда (&)...

Давай попорядку
Программа не работает с адресами. Программа - это набор управляющих команд системе. Система, читая твою программу, будет в случае наличия команд управления адресами с ними и работать. Указатели изначально создавались для ускорения работы и оптимизации работы с ОЗУ. Попробую обьяснить на примере... у тебя есть класс Foo. Ты создал обьект Foo foo; Допустим класс Foo очень сложен и громоздок. Обьект foo занимает много памяти и поэтому в таком случае:

Код

void somefunc(Foo foo_clone) { //Делаем что-то страшное :) } //********************** //Где-то в коде... Foo foo; somefunc(foo);

Приложение уйдет в лучшем случае в глубокий даун, а в худшем при нехватке памяти аварийно завершиться. Для не NT систем может также наблюдаться нарушение целостности памяти других процессов.
Почему это происходит ? на строчке somefunc(foo); система делает ещё одну копию foo и поэтому, при условии, что создание первого обьекта от Foo завершилось успешно, не факт, что памяти хватит под второй. Также в этом примере мы не можем изменить уникальный foo в функции somefunc. Максимум, что мы можем сделать - это изменить его клона.
Теперь пример, как бы можно сделать это правильно:

Код

void somefunc(Foo *lpfoo) { //Делаем что-то страшное :) } //********************** //Где-то в коде... Foo foo; somefunc(&foo);

В этом примере, что наглядно, используется способ передачи параметра функции по ссылке.
В данном случае клон foo не создается, а работа ведется с единственным foo, вернее с указателем на обьект класса Foo, значение которого в результате работы строчки somefunc(&foo) будет адрес foo. В данном примере мы можем работать с уникальными членами foo. Допустим мы можем так изменить public член something(int): lpfoo->something = 1;

Ссылка - Адрес - Указатель... это вещи тесно взаимосвязанные в контексте C++. Адрес - это, если по простому - положение обьекта в памяти. Символ & обозначает взятие адреса. Указатель можно воспринимать, как тип способный хранить адреса на определенно типированную переменную. Указатель по сути не нужен будет, если он не ссылается на какой-то обьект памяти по определенному адресу. Чтобы узнать этот адрес, надо "взять адрес" - это логично.

Это тот пример, который нужен. Стоит добавить, что в С это единственный способ передавать функциям переменные с тем, чтобы они изменялись внутри функции.
В С++ есть еще ссылки. Вот так с ссылкой тот же пример.

Код

void somefunc(Foo &foo_clone) { //Делаем что-то страшное :)  foo_clone.do_horrible_things(); // обращаемся со ссылкой как с самой переменной } //********************** //Где-то в коде... Foo foo; somefunc(foo);

Для таких целей как раз использовать удобнее ссылки.

Цитата

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

Да. Тока слово ссылки стоит применять в контексте к ссылкам, а чтобы термины не путались - бери в кавычки.

Цитата(comcon1 @ 5.8.2005, 15:49)

В С++ есть еще ссылки. Вот так с ссылкой тот же пример.

Цитата(comcon1 @ 5.8.2005, 15:49)

Да. Тока слово ссылки стоит применять в контексте к ссылкам, а чтобы термины не путались - бери в кавычки.

Угу моя ошибка, извиняюсь.

Цитата

В другом ревью оно highly recommended:

Неправильно. Это то же самое ревью, только о другой книге Дейтелов. Понятно? Посмотрите на названия книг, о которых пишут там. А внизу там есть список их литературы - какая рекомендована, а какая нет.
Добавлено @ 19:17
En_t_end, из вашего (кстати, вполне хорошего) объяснения я уяснил одно: лучше всегда пользоваться ссылками, а не указателями. Я все правильно понял? Что такое ссылка, я, в принципе, разобрался.

sim7

Цитата(sim7 @ 5.8.2005, 23:14)

учше всегда пользоваться ссылками, а не указателями. Я все правильно понял? Что такое ссылка, я, в принципе, разобрался.

Все зависет от конкретного примера. Допустим примение указателей - это пожалуй единств. выход в контексте C++ работать с кучей. Единственно удобный универсальный вариант работы с массивами в контексте функции при передачи его в виде параметра.

Код

void somefunc(char *strng)  /*Самый удобный вариант, когда надо получать массив в качестве параметра */ { //что-то делаем с strng. } //Где-то в коде... char *some_pointer = new char[MAX_LONG_STR]; somefunc(some_pointer); //передаем дин. массив char some_str[MAX_LONG_STR]; somefunc(some_str);  //передаем обычный массив

Это сообщение отредактировал(а) En_t_end - 6.8.2005, 10:49

Работа со ссылками не столь разнообразна, сколь с указателями. Там много ограничений. Например список объектов не может быть реализован с помощью ссылок, ведь ссылкам должны передаваться реальные объекты.

+ указателей в том, что отведенная память сохраняется при удалении указателя, а, следовательно, она доступна из любой области видимости.
Однако это и является их минусом, потому что в кривых руках память забывают отводить и это приводит к утечкам (потере указателей на отведенную память).

comcon1

Цитата(comcon1 @ 6.8.2005, 15:44)

Однако это и является их минусом, потому что в кривых руках память забывают отводить

Я думаю это их минусом не является. Это является минусом обладателя кривых рук