Версия для печати темы
Нажмите сюда для просмотра этой темы в оригинальном формате
Форум программистов > C/C++: Для новичков > копирование указателей


Автор: grisWall 6.9.2013, 11:49
Всем доброго времени суток у меня назрел вопрос. Я решил тут на днях написать программку на Си которая принимает в консоли параметры и создает папку с именем и помещает в неё main.c. Что то типа начальный шаблон для автоматизации создания программ в отдельных папках, а то я тут глянул один раз и ужаснулся что у меня в одной папке столько программ и столько  хлама что в пору уже вешаться чем со всем этим разобраться. Я решил написать программку и вроде написал я ее и она мне все создавала. Но вот не задача решил, я начитавшись K&R переписать её указателями. И тут я попал на такую вещь как ошибка сигментирования я то ее реализовал массивами и горя не знал а вот как только я начал делать 
Код

const char * fileName = "main.c";
char file[] = "\t*                       *";
for (i = 0; (k = fileName[i]) != '\0'; i++)
file[3+i] = k;
 с  указателями, 
Код

const char * fileName = "main.c";
char * file = "\t*                      *";
for (i = 0; ((k = *fileName) != '\0'); i++)
fileName++;
*(file + 3 + i) = k;
тогда тут же на меня посыпались камни в виде ошибок сигментирования.

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

Код

const char * fileName = "main.c"
char * file = "\t*                                *";

file = strcpy (file, fileName);


при том что все это компилируется молча.

Автор: leshiysoft 6.9.2013, 11:58
Если просто, то так: 
Потому что в Ваше переменной file лежит указатель на константную строку в сегменте данных, так как вы её задаете прямо в коде. Други словами в куче место под эту переменную не выделялось и аллоков и маллоков небыло. Вот она и ругается, мол, в сегмент данных, содержимое которого формируется в процессе компиляции, нехорошо писать. Нужно руками выделять необходимый объем памяти.

Автор: grisWall 6.9.2013, 12:08
Цитата(leshiysoft @  6.9.2013,  11:58 Найти цитируемый пост)
Если просто, то так:


а если по конкретнее?

Автор: leshiysoft 6.9.2013, 13:41
Правильно так:
Код

const char * fileName = "main.c";
char * file = (char*) malloc (7);
file = strcpy (file, fileName);
free (file);


Все дело в том, что любая строка в кавычках используемая в коде - это const char*, причем располагается она в секторе данных для чтения. Следовательно, записывать в неё нельзя. Для записи нужно вручную выделить память, например, так:
Код

char * file = (char*) malloc (7);


и незабыть очистить память:
Код

free (file);


Кстати можно было не вводить новую переменную fileName и использовать строку в кавычках прямо в аргументах функции strcpy:
Код

char * file = (char*) malloc (7);
file = strcpy (file,  "main.c");
free (file);

так как она (строка в кавычках) имеет нужный для strcpy тип : const char*

Автор: feodorv 6.9.2013, 13:44
Цитата(grisWall @  6.9.2013,  13:08 Найти цитируемый пост)
а если по конкретнее?

Цитата(grisWall @  6.9.2013,  12:49 Найти цитируемый пост)
char * file = "\t*                                *";

Переменная file указывает на область в памяти процесса, в которой находятся символы '\t', ' ' ... ' ', '*', '\0'
Проблема в том, что эта область памяти защищена от записи. Так её создал и определил компилятор, что вполне корректно, ибо строковый литерал по своей сути - константа.
Более того, если Вы создадите ещё одну подобную переменную, указывающую на ту же самую строку:
Код
char * file = "\t*                                *";
char * filo = "\t*                                *";
то вполне может оказаться так, что значения file и filo (то есть адреса строк) совпадают (то есть они указывают на одну и туже область памяти, а не на разные, но с одинаковым содержанием).

Что делать? Самый простой способ - это воспользоваться инициализированным массивом:
Код
char fileBuf[100] = "\t*                                *";
char *file = fileBuf;
Тогда уже file будет указывать на изменяемую область памяти.

Добавлено через 2 минуты и 17 секунд
Цитата(leshiysoft @  6.9.2013,  14:41 Найти цитируемый пост)
char * file = (char*) malloc (7);

А без выделения памяти никак???

Добавлено через 5 минут и 30 секунд
Цитата(feodorv @  6.9.2013,  14:44 Найти цитируемый пост)
Тогда уже file будет указывать на изменяемую область памяти.

Да, нужно заметить, что эта изменяемая память ограничена в размерах - 100 байт и не более. В случае выхода за её пределы:
Код
file[100] = ' ' ;
возможен очередной SIGSEGV, а если он не произойдет, то всё равно это приведёт к непредсказуемому поведению программы.

Автор: leshiysoft 6.9.2013, 13:50
Массив действительно подойдет, так как массив в С - это ничто иное как указатель. И память выделенную под массив не нужно очищать. Но в случае если размера массива вам будет нехватать надо будет переписывать и перекомпилировать программу. Особенно это неприятно и неправильно, когда необходимый размер под строку заранее неизвестен, например, зависит от размера строки введенной пользователем.

Автор: feodorv 6.9.2013, 14:13
Цитата(leshiysoft @  6.9.2013,  14:50 Найти цитируемый пост)
Но в случае если размера массива вам будет нехватать надо будет переписывать и перекомпилировать программу.

Это да. Довольно часто возникают задачи, в которых необходимый объём памяти заранее не известен. С другой стороны, на мой взгляд, ещё чаще программисты недооценивают возможность воспользоваться массивом)))

Но в любом случае придётся тщательно рассчитывать необходимый размер. Чаще всего, этот размер вполне комфортный и ограничен сверху разумной константой, так почему бы в таком случае не использовать массив? 

Тщательность определения необходимого размера памяти демонстрирует и этот пример:
Цитата(grisWall @  6.9.2013,  12:49 Найти цитируемый пост)
const char * fileName = "main.c";
char file[] = "\t*                       *";
for (i = 0; (k = fileName[i]) != '\0'; i++) file[3+i] = k;


Хорошо, что здесь sizeof("main.c")+3 меньше или равен чем sizeof("\t*                       *"). А если больше:
Код

const char * fileName = "/disk2/mount/v/usr/abracadabra/projects/my/k&r/test1/main.c"


Опять непонятный SIGSEGV?

Автор: grisWall 6.9.2013, 23:23
да я кстати замечу что у меня то в коде изначально я реализовал массивами все это дело вот так: 
Код

char fileName[] = "main.c";
char prog[48] = "\t*                                                 *";    // сюда помещаем название программы
char file[48] = "\t*                                                  *";    // сода помещаем название файла
for (i = 0; (k = fileName[i]) != '\0')
   file[3+i] = k;
for (i = 0; (k = argv[0][i]) !='\0')
   prog[3+i] = k;


это я уже для эксперименту решил по пробовать получиться может изящнее или эффективнее вот и напробовался блин так что мама не горюй щас все вернул назад даже что-то доработал в старой версии. Так что всем спасибо за дельные советы все очень помогли особенно с malloc и free а по поводу определения размера у массива я тоже взял на заметку... спасибо.
Цитата

Автор: akizelokro 7.9.2013, 10:49
Цитата(grisWall @  6.9.2013,  23:23 Найти цитируемый пост)
// сода помещаем название файла

Смотри, есть системные требования, например, для максимальной длины названия файла (вместе с путём).
Вердикт. Массиву сразу присваешь такую размерность. Не экономь сотню байтов, зато потом ты лишний раз нигде не будешь удивлятьс. Это раз.

Автор: feodorv 7.9.2013, 11:43
Цитата(akizelokro @  7.9.2013,  11:49 Найти цитируемый пост)
Смотри, есть системные требования, например, для максимальной длины названия файла (вместе с путём).
Вердикт. Массиву сразу присваешь такую размерность. Не экономь сотню байтов, зато потом ты лишний раз нигде не будешь удивлятьс. Это раз.

Ну, тут немного другие требования. Готовится вывод на экран в "красивом" виде))) Следовательно, нужно не увеличивать буфер под возможности файловой системы, а ограничить длину имени файла:
Код

char prog[64] = "\t*                                                 *";    // сюда помещаем название программы
char file[64] = "\t*                                                  *";    // сода помещаем название файла
for (i = 0; i < 48 && (k = fileName[i]) != '\0'; ++i)
   file[3+i] = k;
for (i = 0; i < 48 && (k = argv[0][i]) !='\0'; ++i)
   prog[3+i] = k;


Кстати:
Цитата(grisWall @  7.9.2013,  00:23 Найти цитируемый пост)
char prog[48] = "\t*                                                 *";    // сюда помещаем название программы
char file[48] = "\t*                                                  *";    // сода помещаем название файла

48 байт явно мало для строки "\t*                                                  *" smile 

Автор: ТарасАтавин 7.9.2013, 12:26
Цитата(grisWall @  6.9.2013,  11:49 Найти цитируемый пост)
Всем доброго времени суток у меня назрел вопрос. Я решил тут на днях написать программку на Си которая принимает в консоли параметры и создает папку с именем и помещает в неё main.c. Что то типа начальный шаблон для автоматизации создания программ в отдельных папках, а то я тут глянул один раз и ужаснулся что у меня в одной папке столько программ и столько  хлама что в пору уже вешаться чем со всем этим разобраться. Я решил написать программку и вроде написал я ее и она мне все создавала.
Вместо перемещения файлов средствами интерфейса системы конечно же надо дописать специальную прогу к имеющейся помойке, потом ещё одну для её запуска и передаче ей параметров, потом для её запуска и передаче параметров ей и так пока весь винт на это не изведёшь. Так держать.

Автор: akizelokro 7.9.2013, 12:49
Руку на чем-то набивать ему надо

Автор: ТарасАтавин 7.9.2013, 13:34
Цитата(feodorv @  7.9.2013,  11:43 Найти цитируемый пост)
Ну, тут немного другие требования. Готовится вывод на экран в "красивом" виде))) Следовательно, нужно не увеличивать буфер под возможности файловой системы, а ограничить длину имени файла:
А про терминальный ноль знаешь?

Powered by Invision Power Board (http://www.invisionboard.com)
© Invision Power Services (http://www.invisionpower.com)