Использование char * в C++ для строк

#include<iostream>
using namespace std;
int main()
{
char *a;
cin>>a;
cout<<a;/*when input is string it gives segmentation fault*/
char* b="hello";/*while this thing works fine*/
cout<<b;
}

В чем разница между двумя точно?

Если явно не инициализированы, локальные переменные никоим образом не инициализируются, их значения неопределенны (и на самом деле будут казаться случайными). Это означает, что ваш указатель a скорее всего не укажет на правильное местоположение, поэтому, когда вы используете его для ввода ввода, программа будет записывать в некоторая память, которой она не владеет, что приводит к неопределенному поведению (что является наиболее распространенной причиной сбоев).

Когда вы определяете переменную b вы указываете, что компилятор должен указывать на определенное место, на массив символов, созданный компилятором и принадлежащий программе. Вы инициализируете переменную, поэтому ее использование будет работать. Однако обратите внимание, что строковые литералы представляют собой массивы символов, которые считаются доступными только для чтения, поэтому, чтобы быть правильными, вы должны действительно делать

const char* b = "hello";

во втором примере память, выделенная компилятором, является особым местом для строкового литерала, в первом примере такого пространства нет…

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

но вы могли бы в теории сделать что-то вроде (я думаю… если поток переопределяет работу так:

char *a = (char *)malloc(500);
cin >> setw(500) >> a;

Вы должны выделить место для хранения символов, в

cin >> a;

вы храните их в недопустимом месте, так как указатель a char еще не указывает на действительную память, поэтому вам нужно указать на действительный блок, который

1. Вы можете запросить с помощью new оператора, как это

   a = new char[length];
   cin >> a;
   

   но вам нужно быть осторожным

   delete[] a;
   

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

2. Объявите его как массив вроде

   char a[100];
   cin >> a;
   

   тогда будет.

Но вам следует избегать этого в c++ и вместо этого использовать std::string.

char *a;// it is pointer which is memory was unallocated.

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

char *b="hello";

"hello" будет храниться в памяти только для чтения. Так что cout просто распечатает этот контент.

Вы указали указатель, но вы не отложили память для хранения самой строки. В вашем коде a не был инициализирован, чтобы указать значение смысла в любом месте. Вам нужно либо установить его на существующий буфер:

char buf[SOME_SIZE];
char *a = buf;

или вам необходимо выделить эту память во время выполнения:

char *a = new char[SOME_SIZE];

Причина

char *b = "hello";

работает то, что пространство было зарезервировано для хранения строкового литерала "hello", а адрес этой строки присваивается букве b. Обратите внимание, что попытка обновления содержимого строкового литерала вызовет неопределенное поведение (по крайней мере, на C, и я уверен, что это правда в C++), поэтому вы не хотите писать что-то вроде

cin >> b;

пока b указывает на литерал.

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

Первая конструкция:

char *a;
cin>>a;

использует неинициализированную переменную указателя a. Это приводит к неопределенному поведению, когда программа может вылететь из строя или отправить сердитые электронные письма президенту Swizz или делать то, что, по вашему мнению, это будет делать, что бы то ни было. Компилятор обязан создать исполняемый файл, но может выдавать предупреждение.

Вторая конструкция:

char* b="hello";

недопустимо в стандарте C++. Стандарт C++ не обеспечивает преобразование из строкового литерала в char*. Некоторые компиляторы могут, тем не менее, принять его, а затем инициализировать b указателем на первый символ в строке "hello".

Вместо того, чтобы обращаться с необработанными указателями и т.д., Вы должны использовать std::string, например:

#include <iostream>
#include <string>
using namespace std;

auto main() -> int
{
string a;
getline( cin, a );
cout << a << "\n";
string const b="hello";
cout << b << "\n";
}