Пишу я к примеру
char *myvar = "sdfsdf";
Очевидно, выделяется 7 байт памяти. Не должен ли я их освобождать самостоятельно? Т.е. понятно, что когда я пишу
char myvar[255] = "sdfsd";
То все ок., т.к. данные размещаются в памяти статически. А вот в случае динамического размещения?
Или еще пример:

Код

char *var1, *var2; var1 = "sdfsdfd"; //выделилась память. надо ли освобождать? var1 = var2; //var1 просто указывет туда же, куда var2 var1 = "ggggg"; //теперь содержимое var2 тоже равно ""ggggg"

Все ли я понимаю правильно?
Вообще работа с указателями как-то неочевидна. Как я могу различить, когда я присваиваю значение указателю, а когда - тому на что он указывает?
Скажем, у меня есть
int *v;
я хочу выделить под него память. как это сделать? и как ее потом освободить?
допустим, я сделал это. Хочу изменить то значение на которое указывает v. Я пишу:
v = 0xFFFFFF;
А теперь я хочу сделать так, чтобы v указывал на участок памяти по адресу 0xFFFFFF. Как это сделать?
Вопрос next. Некоторая функция возвращает мне строку, под которую она очевидно распределила память. Как мне освободить эту памть?
Спасибо за внимание

Цитата

Вообще работа с указателями как-то неочевидна. Как я могу различить, когда я присваиваю значение указателю, а когда - тому на что он указывает?

указатель это просто v=....
а значение *v=5;
Освобождать желательно, это как правила хорошего тона.

Цитата

я хочу выделить под него память

int *v;
int o;
v=new int;
*v=5; сдесь по адрессу куда указывает v заноситься 5
o=4;
v=&o; теперь v указывает на о в котором записано 4

Цитата

и как ее потом освободить?

delete v;

Это сообщение отредактировал(а) Step - 27.2.2003, 01:57

Почитай внимательно про область видимости и операторные скобки {....};

Цитата

Хочу изменить то значение на которое указывает v. Я пишу: v = 0xFFFFFF;

это не правильно
правильно вот так

Цитата

Хочу изменить то значение на которое указывает v. Я пишу: *v = 0xFFFFFF;

А как же со строками? Почему прокатывает
char *v;
v = "sdfsdfsdf";
И как в этом случае выделять/освобождать память?

Цитата

Пишу я к примеру char *myvar = "sdfsdf"; Очевидно, выделяется 7 байт памяти. Не должен ли я их освобождать самостоятельно? Т.е. понятно, что когда я пишу char myvar[255] = "sdfsd"; То все ок., т.к. данные размещаются в памяти статически. А вот в случае динамического размещения?

Это точно такое же статическое размещение. Строка "sdfsdf" размещается в области глобальных данных, а myvar указывает на эту область. Так что в данном случае ничего освобождать не надо.

Цитата(dAnIK @ 26.2.2003, 22:29)

char *var1, *var2; var1 = "sdfsdfd"; //выделилась память. надо ли освобождать?

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

Это сообщение отредактировал(а) Alex101 - 27.2.2003, 03:59

а не легче делать char *var = new char; тут ясно и понятно, что так, мол, и так, выделяю память под мой var. А потом просто delete var;

Цитата(Alex101 @ 27.2.2003, 00:57)

Цитата(dAnIK @ 26.2.2003, 22:29) char *var1, *var2; var1 = "sdfsdfd"; //выделилась память. надо ли освобождать? А так нельзя делать.

Можно. Антон уже сказал. Строковый литерал (типа "....") имеет тип, точно не скажу какой, но, можно считать, что char* и выделяется статически, скорее всего в сегменте данных, и лежит там всегда с начала запуска программы до ее уничтожения.
Когда вы присваиваете указателю char* значение такого литерала, вы просто записываете в указатель значение памяти, где лежит эта строка.

Цитата

а не легче делать char *var = new char; тут ясно и понятно

Легче разобраться, и никаких проблем.

2Fantasist Точно, строка в сегменте данных лежит. Потом в указатель ее адрес помещается.
Сори всем за свои поспешные выводы.
Но все равно, так делать, скажем, некрасиво, что ли.... (с точки зрения кода)

Цитата(Kefir @ 26.2.2003, 21:36)

а не легче делать char *var = new char;

так, будет выделено памяти только под один символ.

Цитата

а не легче делать char *var = new char; так, будет выделено памяти только под один символ.

А так правильнее?

Код

char *var = new char[255];

ЗЫ.
Спасибо всем огромное за ответы

Цитата(Step @ 27.2.2003, 02:42)

int *v; int o; v=new int; *v=5; сдесь по адрессу куда указывает v заноситься 5 o=4; v=&o; теперь v указывает на о в котором записано 4

2 Step: Это же плохой пример, т.к. выделив сначала память

Код

v=new int;

, а потом "перекинув" указатель:

Код

v=&o;

мы теряем память...

2 Fantasist: строковый литерал имеет тип const char*...

Цитата

А как же со строками? Почему прокатывает char *v; v = "sdfsdfsdf"; И как в этом случае выделять/освобождать память

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

Цитата

2 Step: Это же плохой пример, т.к. выделив сначала память Код v=new int; , а потом "перекинув" указатель:   v=&o; мы теряем память...

ты конечно прав, но только в том случае если pyfxtybt *v на месте ..... не использовалось

Цитата

*v=5; сдесь по адрессу куда указывает v заноситься 5 ...... o=4;

ну а при переадресации желательно конечно сделать делет

Цитата

2 Fantasist: строковый литерал имеет тип const char*...

Если было бы так, я бы не смог присвоить его значение не константному указателю. То есть такое не компилировалось бы:

Код

char *var1; var1 = "sdfsdfd";

Скорее этот тип char const*

Но на самом деле, он имеет тип char[] Что, в общем-то, совершенно логично.

P.S. Для интересующихся: в VC++ посмотрите на сообщение компилятора, на такое выражение:
("dfdfsd")=(char*)(0x1);

Это сообщение отредактировал(а) Fantasist - 28.2.2003, 01:44

Цитата

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

Мало того. Если написать что-то вроде такого

char* var1 = "12345";
char* var2 = "12345";

то оптимизатор скорее всего оставит всего одну строку в сегменте данных, а обоим указателям присвоит один и тот же адрес.

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

Хотя хорошо, что такой вопрос возник - значит думаем, смотрим, замечаем.
Хорошая смена нам, старикам, растет

Цитата

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

Вряд ли. Это очень опасное предположение - нет никакой гарантии, что я не хочу изменить первую строку не изменяя второй.

Цитата

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

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

Цитата

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

Разве что в простешем случае. Я могу сохранить этот адрес в переменной, и изменить в другом юните компиляции - оптимизатор туда заглянуть не может.

Fantasist а ты выставь максимальный уровень проверки, и посмотри предупреждения при компиляции

Смотрю СтраусТрупа
В "С" строковый литерал имел тип char*, а в С++ - const char[]. Для совместимости кода С и С++ разрешается присваивание char* p = "abc"; Но вот изменение, например: p[0] = 'A' приведет к ошибке. На счет "оптимизатора"... В VC++6 результатом такого кода:

Код

char* var1 = "12345"; char* var2 = "12345"; if (var1==var2) cout<<"EQUAL!/n";

будет надпись "EQUAL!".
Что и требовалось доказать

Цитата

Но вот изменение, например: p[0] = 'A' приведет к ошибке

*(p+1)='d' - прокатит

Цитата

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

В VisualC компилятор будет делать это только если включена опция /Gf или /GF, не знаю как Builder.

Цитата

В "С" строковый литерал имел тип char*, а в С++ - const char[].

Значит VC расходиться здесь со стандартом. Если считать, что он должен быть const char[], то тогда можно и оптимизацию вышеописанную проводить.

Цитата(Step @ 28.2.2003, 20:43)

Цитата Но вот изменение, например: p[0] = 'A' приведет к ошибке *(p+1)='d' - прокатит

не прокатит (специально попробывал запустить прогу)

Цитата

не прокатит (специально попробывал запустить прогу)

прокатит, нужно слегка по упрожняться с преобразованием типов и все получиться

Хочу сделать замечание. Если необходимо удалить кусок памяти, выделенный так:

char *ptch = new char [1024]; ,

то вроде как надо писать

delete [] ptch;

Это обязательно?
Причём насколько я знаю, в книжках (я прочитал с полтора десятка) ничего на эту тему нет, этот вопрос подробно освещён только в одной - как-то там про VC++. Там ещё пишут, что если квадратные скобки опустить, то высвободится память только из под первого объекта.
Вопрос не по теме: я воще новичок, ничо, что я везде суюсь?

Цитата

Причём насколько я знаю, в книжках (я прочитал с полтора десятка) ничего на эту тему нет, этот вопрос подробно освещён только в одной - как-то там про VC++. Там ещё пишут, что если квадратные скобки опустить, то высвободится память только из под первого объекта.

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

Цитата

Это обязательно? Причём насколько я знаю, в книжках (я прочитал с полтора десятка) ничего на эту тему нет

Ничего себе! Как это нет? Что же это за книжки такие? Если используется new[] то для него необходимо использовать delete[].

Цитата

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

Помниться, по этому вопросу (о необходимости delete[]) большое обсуждение было. Вообще, как пологается по стандарту, я уже сказал, а вот как реализуют это компиляторы - вопрос другой. Чаще всего, и именно для такой реализации стандарт таким образом и был придуман, когда выделяется память с помощью new - где-то (положим, на два байта выше выделенного блока) сохраняется размер выделенного куска. Если выделение памяти происходит с помощью new[] - то сохраняется и количество выделенных элементов. А зачем нам это количество? Ведь delete может просто взять сохраненный размер выделенного блока и грохнуть его. Для простых типов это действительно так, но для пользовательских нужно знать сколько раз вызвать деструктор. То есть так и получается, что для простых типоа достадочно было и одного delete , а delete[] в общем-то излишен, однако для сложных типов это не так. С другой стороны, можно было бы всегда сохранять количество выделенных элементов, в независимости от того, используется new или new[] , однако это не так экономно, с точки зрения расходуемой памяти. Зачем хранить количество элементов для new, когда и так понятно, что он один?
Так и получается, что предпологается, что delete не смотрит на количество элементов (то есть просто считает, что он один), а delete[] смотрит. В большинстве реализаций, для простых типов, уничтожение с помощью delete будет оказывать тот же эффект, что и delete[] , так как сохраняется размер всего выделенного блока, а не размер элемента*количество элементов. Так что если применить delete, для памяти выделенной с помощью new[] , то память освободиться вся, но деструкор будет вызван только для первого элемента.