Здравствуйте, при работе программы возникает такая вот ошибка:


Путем отладки выяснил, что возникает она при вызове функции приблизительного следующего вида (лишний код я опустил для конкретики).


Конкретно, строка, на которой ошибка возникает: 
 
Возникает ошибка при втором или третьем обращении к данной функции, что именно меня и смущает. Прошу помочь разобраться. С понятием указателя (char*) знаком, менее осведомлен в механизмах преобразования.
Заранее спасибо!

strace вам в помощ

так нельзя. ты пытаешься явно преобразовать указатель на char к классу string.
Нужно создать экземпляр класса string и передать ему в конструкторе указатель на char

и ещё. если ты не собираешься изменять данные по указателю input, сделай его const-овым

если ты не собираешься изменять данные по указателю  ? что дает const ?
можно написать  ++input; или (input+5)=10;

то, что при вызове этой функции (MyF) ей можно передать констовый указатель, и быть уверенным, что данные по этому указателю не будут изменены



если имеется в виду, что input - констовый указатель, то
++input можно, т.к. данные по указателю не изменяются, а
(input+5)=10 вообще нельзя, т.к. input+5 - rvalue. если же ты имел в виду *(input+5)=10, то так тоже нельзя,
т.к. если input - констовый указатель, то и (input+5) - тоже констовый указатель.

Позвольте вопрос, а почему у меня как минимум 2 раза подобный финт ушами 

прокатывал? 
Как минимум один раз это неявное преобразование срабатывало?

Zerstroer, походу ступил малёха...
в данном случае

и

одно и то же (хотя, вообще-то, предпочтительнее использовать второй вариант)

может быть у тебя в случае, когда программа падает, input указывает на мусор ? или равен NULL ?
распечатай input:

Того, что ступил - не исключаю!
Входную переменную char* input отслеживал.
Но.
1. При использовании 

всё работает!
2. А при использовании 

всё вываливается после 2-3 прогона.
Единственная предположительная догадка - input оканчивается не char(0) символом, а чем-то неведомым (насколько корректно формируется input сказать не могу - input подается из закрытого класса).

это я про себя говорил 
если 

то предположение, что

выглядит неправдоподобным.

всё-таки так

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

Не понимаю, зачем вообще использовать явное приведение?
И всё.  

Но похоже ошибка не здесь.

это очень похоже, версия: Идет какойто очень длинный набор данных, malloc не может выделить так много и выпадает.
А иногда работает, потому-что в этом потоке данных случайно встретился '\0'.
Наличие или отсутствие '\0' может возникать от самых разных причин, так как строка перекрывает другие переменные, может стек, да вообще что угодно.

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

volatile, 
Так, как вы сказали

точно нельзя! У меня input - указатель!

В принципе, первоначальную задачу я решил. Причины, по сути - не конкретны, проще запомнить верный метод.

borisbn, спосибо большое! Пошел учить специфику конструкторов/деструкторов стандартных классов.
Задача выполнена. Всем спасибо!

Добавлено через 3 минуты и 50 секунд
Задача решена. Правильный ответ 
string s = string( input );

класс std::string имеет конструктор принимающий указатель на чар.
У вас видимо, что-то другое, не std::string

 у меня именно std::string. 
На синтаксис 

у меня ругается компиллятор, input - не const char*, а просто char*.
В конечном итоге, передача в конструктор идет способом, в первом же посте описанном borisbn

если не собираетесь менять input, объявите функцию как:
string MyF(const char* input)

если собираетесь

string s =  (const char*)input;

Добавлено через 10 минут и 39 секунд
это вообще кривость компилятора.

input - изменяемый.

 - такое я в первый раз вижу, но при возможности проверю и приму на вооружение! 

Если не работает 
string s = input;

то не должен работать и 
= string( input );

в обоих случаях вызывается конструктор string( const char* )


это явно кривой компилер. У вас под линухом видимо это нармально, господа линуксоиды ???  

*ловит камень летящий в огород*
Да самый лучший компилер! 
gpp/g++!
Это у вас неподлинуксом нормально когда
!!!
А линукс система до крайностей адекватная!
Вот придёт borisbn и всё разъяснит!
Ладно, считаю дальнейшую палемику нежелательным флудом.  

во всех компиляторах, которые я знаю, это - одно и то же !!!

Zerstroer, у тебя, скорее всего, какой-то ну очень древний компилятор...
тем более, что 

по стандарту как раз обратное преобразование невозможно. а вот char * -> const char * - это не просто нормально, а супернормально.

string s = string( input );

здесь что происходит. сначала создается временный объект string, назовём его t
t = string( input );
потом создается объект s.
s (t);

а в строчке
string s = input;
никаких временных объектов не создается. и дело проходит за 1 шаг вместо 2-ух.


привет линуксоидам!!!

линухоидов тоже не люблю, но, думаю, что cl.exe, что gcc разберуться и тупо один раз вызовут конструктор для вновь создаваемого объекта. впрочем ничего не мешает проверить: включить компиляцию через ассемблер - и вперёд 

borisbn, да дело не в оптимизаторе.
почему в принципе нужно писать лишний код, и надеяться что оптимизатор это исправит?

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

borisbn, ну здесь не могу не согласиться.

Zerstroer, а вам все-же посоветую сменить компилер.
к линуксоидам, кстати, я нормально отношусь. 
 

нет, это ненормально. У меня проблем с конвертацией char* в const char * никогда не было.


Итак, есть два вида конструкторов.implicit и explicit. Все конструкторы по умолчанию implicit. Это значит, что код:Полностью идентичен - будет вызван один раз конструктор класса string.
Если бы конструктор string::string(const char *) был бы объявлен так: explicit string(const char *); то первый вариант просто бы не скомпилировался.
А вот код:уже отличается от вышеприведенных. Так как в этом случае будет: вызов конструктора string::string(const char*), затем string::string(const string&) - конструктора копирования, и наконец деструктора string::~string().