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

Потому что char* не является строкой. Это просто указатель на какой-то символ с условием, что за ним может следовать больше символов и что после последнего стоит '\0'.

Строковый литерал в C (и, следовательно, в C++), такой как "abc", представляет собой просто массив символов, к которому компилятор молча добавляет '\0'. Когда вы присваиваете массив указателю, массив автоматически преобразует указатель в первый элемент. Результат в том, что

at = "tw";

означает, что указателю at назначается адрес первого символа в строковом литерале "tw". Тем самым он потеряет свою старую ценность. Поскольку это был адрес динамически выделяемого массива символов, вы пропускаете этот массив.

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

Позже вы передаете at в delete[] (и не delete, так как вы вызвали new[], а не new). При этом вы передаете ему адрес строкового литерала вместо выделенного массива символов. Это, конечно, испортит работу диспетчера кучи. (Библиотека времени выполнения VC улавливает это в режиме отладки.)

std::strcpy, с другой стороны, копирует строку символ за символом из одного массива в другой массив. Никакие указатели не будут изменены, копируются только участки памяти. Указатель на целевой массив после этого по-прежнему указывает на целевой массив, изменились только данные в этом массиве.

Позвольте мне добавить следующее: Если вы новичок в C++, вам следует использовать std::string, а не строки C. Это делает за вас всю грязную работу и имеет разумную семантику.

Когда вы делаете

char *at = ...;

at = "hello";

Вы в основном перезаписываете значение указателя (т. е. адрес памяти, выделенной для вас new[]) адресом статической константной строки. Это означает, что когда вы позже удаляете эту память, вы передаете delete указатель, который ранее не возвращался new.

Это плохо.

В C и C++ присваивания указателям обычно ничего не делают с памятью, на которую они указывают, они изменяют сам указатель. Это может сбивать с толку, если вы привыкли к языку, в котором строки являются скорее «гражданами первого класса».

Кроме того, вы должны использовать delete[], если вы использовали new[].

Есть три вещи, которые нужно понять:

1) char *at; — это просто переменная-указатель.
Переменная-указатель просто означает, что она содержит адрес памяти.

2) new char[3] возвращает начальный адрес памяти, выделенной в куче.

3) "hello" возвращает адрес строкового литерала.

char *at = new char [3];
//at now contains the address of the memory allocated on the heap


at = "hello";
//at now contains the address of the static string. 
// (and by the way you just created a 3 byte memory leak)


delete[] at; 
//WOOPS!!!! you can't do that because you aren't deleting 
// the original 3 chars anymore which were allocated on the heap!
//Since at contains the string literal's memory address you're 
// trying to delete the string literal.

Примечание об изменении памяти только для чтения:

Также вы никогда не должны изменять строковый литерал. т.е. этого никогда не следует делать:

char *at = "hello";
at[2] = '\0'; 

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

Поскольку вы используете C++:

Поскольку вы используете C++, рассмотрите возможность использования вместо этого типа std::string.

#include <string>

using namespace std;

int main(int argc, char **argv)
{
  string s = "hello";
  s += " world!";

  //s now contains "hello world!"

  s = "goodbye!";

  //Everything is still valid, and s contains "goodbye!"


  //No need to cleanup s. 

  return 0;
}

Не забудьте использовать

delete []

всякий раз, когда вы выделяете что-то с помощью [].

Указатель содержит адрес. Оператор = для указателя изменяет удерживаемый адрес.

at = "tw";

Указывает на массив "tw" (массив, созданный компилятором для хранения символов tw), он больше не указывает на массив, который вы создали с помощью new. создается в файле.

at[2] = '\0';

Добавляет NULL в конец массива компилятора.

В первом примере вы меняете значение at, во втором — значение того, на что указывает at. Присвоение char * строке с двойными кавычками присваивает ей статический константный указатель.

В частности, в первом примере сейчас указывает другое место в памяти.

В вашем первом примере вы выделяете некоторую память и указываете на нее с помощью переменной «at». Когда вы делаете

at = "tw"

вы фактически повторно указываете char * на постоянную строку символов. Это приводит к утечке памяти. Когда вы продолжаете удалять «at», вы пытаетесь удалить память стека.

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

В первом примере вы вызвали утечку памяти.

Ваша переменная at является указателем на адрес памяти, а не на саму строку. Когда вы назначаете адрес "tw" указателю, вы теряете исходный адрес, который вы получили с помощью new. at теперь указывает на адрес, который вы не выделили с помощью new, поэтому вы не можете его delete.

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

char *at = new char[3];    // 0x1000
at = "tw";                 // 0x2000
at[2] = '\0';              // set char at 0x2002 to 0
delete at;                 // delete 0x2000 (whoops, didn't allocate that!)

Вы ошибаетесь в двух вещах: указываете указатель на что-то другое (это то, что делает присваивание) и копируете некоторые данные в место, указанное указателем.

at = "tw";

этот код заставляет at указывать на буквальное «tw», созданное где-то в постоянной памяти. Попытка написать на него - поведение undefined.

char *at = new char [3];
strcpy(at,"t");

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

И помните, что память, выделенная с помощью new[], должна быть освобождена с помощью delete[], а не delete.

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