Беспорядок струн до

Чар * имя , на свой собственный, не может держать какие-либо персонажи . Это важно.

имя CHAR * просто объявляет, что имя - указатель (то есть переменная, значение которой является адресом), который будет использоваться для хранения адреса одного или нескольких символов в какой-то момент позже в программе. Это, однако, не выделяет любое пространство в памяти, чтобы фактически удерживать эти символы, и не гарантирует, что имя даже содержит действительный адрес. Таким же образом, если у вас есть декларация, такая как int Number Нет способа узнать, какова стоимость номера , пока вы явно не установите его.

Так же, как после объявления значения целого числа, вы можете позже настроить его значение ( Number = 42 ), после объявления указателя на CHAR, вы могли бы позже установить свое значение, чтобы быть действительным адресом памяти который содержит символ - или последовательность символов - что вас интересует.

Из моих исследований, кажется, что взрыва .NET теперь был прекращен. Однако это , вероятно, поможет.

Обновление: 1 , похоже, требует платной компоненты, Это , вероятно, является лучшим выбором.

Один - это фактический объект массива, а другой - это ссылка или указатель для такого объекта массива.

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

Разница видно в значении и имя . В первых двух случаях это одно и то же значение, что и только что имя , но в третьем случае это другой тип называется указатель на указатель для Char , или ** CHAR , и это адрес самого указателя. То есть это двойной косвенный указатель.

#include <stdio.h>

char name1[] = "fortran";
char *name2 = "fortran";

int main(void) {
    printf("%lx\n%lx %s\n", (long)name1, (long)&name1, name1);
    printf("%lx\n%lx %s\n", (long)name2, (long)&name2, name2);
    return 0;
}
Ross-Harveys-MacBook-Pro:so ross$ ./a.out
100001068
100001068 fortran
100000f58
100001070 fortran

, который является указателем. Это означает, что это переменная, которая удерживает адрес в памяти. Это «точки» в другую переменную.

На самом деле он не может - сам по себе - удерживайте большое количество персонажей. Само по себе он может удерживать только один адрес в памяти. Если вы назначаете его символы при создании, он выделит пространство для этих символов, а затем укажите этому адресу. Вы можете сделать это так:

char* name = "Mr. Anderson";

Это на самом деле в значительной степени так же, как это:

char name[] = "Mr. Anderson";

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

char *name;
name = malloc(256*sizeof(char));
strcpy(name, "This is less than 256 characters, so this is fine.");

попеременно, вы можете назначить ему функцию strdup () , как это:

char *name;
name = strdup("This can be as long or short as I want.  The function will allocate enough space for the string and assign return a pointer to it.  Which then gets assigned to name");

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

if(name)
    free(name);
name = 0;

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

Причина, по которой вы видите указатели персонажей, используются в целом в C, заключается в том, что они позволяют переназначить строку со строкой другого размера. Статические массивы символов не делают этого. Они также легче пройти.

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

char *name;

char joe[] = "joe";
char bob[] = "bob";

name = joe;

printf("%s", name);

name = bob;
printf("%s", name);

Это то, что часто происходит, когда вы передаете статически выделенный массив на функцию, принимая указатель символов. Например:

void strcpy(char *str1, char *str2);

Если вы тогда пропустите это:

char buffer[256];
strcpy(buffer, "This is a string, less than 256 characters.");

Он будет манипулировать обоими теми через STR1, так и STR2, которые являются только указателями, которые указывают на то, где буфер и литерал струны хранятся в памяти.

что-то, что нужно помнить при работе в функции. Если у вас есть функция, которая возвращает указатель символов, не возвращайте указатель на статический массив символов, выделенного в функции. Он выйдет из охвата, и у вас будут проблемы. Повторите, не делай этого:

char *myFunc() {
    char myBuf[64];
    strcpy(myBuf, "hi");
    return myBuf;
}

, который не будет работать. Вы должны использовать указатель и распределять память (например, показано ранее) в этом случае. Затем выделенная память будет сохраняться, даже когда вы выходите из функций. Просто не забудьте освободить его, как упоминалось ранее.

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

Edived для удаления кода C ++. Я смешаю два так часто, я иногда забываю.

Shar * Name - это всего лишь указатель. Где-то вдоль линии памяти должен быть выделен и адрес этой памяти, хранящейся в имя .

• Это может указывать на один байт памяти и быть «истинным» указателем на один символ.
• Это может указать на непрерывную область памяти, которая содержит ряд символов.
• Если эти персонажи случаются, чтобы закончиться нулевым терминатором, низким и вотму, у вас есть указатель на строку.

Это действительно сбивает с толку. Важно понимать и различать, что char name[] объявляет массив, а char* name объявляет указатель. Эти двое являются разными животными.

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

Важно различать разницу между массивом и указателем на первый элемент массива. Размер массива, объявленного как char name[15] можно запросить, используя оператор sizeof:

char name[15] = { 0 };
size_t s = sizeof(name);
assert(s == 15);

, но если применить sizeof к char* name, то на вашей платформе получится размер указателя (т.е. 4 байта):

char* name = 0;
size_t s = sizeof(name);
assert(s == 4); // assuming pointer is 4-bytes long on your compiler/machine

Также две формы определения массивов элементов char эквивалентны:

char letters1[5] = { 'a', 'b', 'c', 'd', '\0' };
char letters2[5] = "abcd"; /* 5th element implicitly gets value of 0 */

Двойственная природа массивов, неявное преобразование массива в указатель на его первый элемент, в языке C (а также C++) указатель может быть использован в качестве итератора для прохождения по элементам массива:

/ *skip to 'd' letter */
char* it = letters1;
for (int i = 0; i < 3; i++)
    it++;

В C строку на самом деле является просто массивом символов, как вы можете увидеть по определению. Однако, внешне, любой массив - это просто указатель на свой первый элемент, см. Ниже для тонких тонкостей. Нет проверки диапазона в C, диапазон, который вы поставляете в объявлении переменной, имеет только значение для распределения памяти для переменной.

A [X] такой же, как * (A + X) , то есть разведка указателя a увеличивается на X.

Если вы использовали следующее:

char foo[] = "foobar";
char bar = *foo;

BAR будет установлен на «F»

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

В некоторых случаях указатель на самом деле семантически отличается от массива, (неисторный) список примеров:

//sizeof
sizeof(char*) != sizeof(char[10])

//lvalues
char foo[] = "foobar";
char bar[] = "baz";
char* p;
foo = bar; // compile error, array is not an lvalue
p = bar; //just fine p now points to the array contents of bar

// multidimensional arrays
int baz[2][2];
int* q = baz; //compile error, multidimensional arrays can not decay into pointer
int* r = baz[0]; //just fine, r now points to the first element of the first "row" of baz
int x = baz[1][1];
int y = r[1][1]; //compile error, don't know dimensions of array, so subscripting is not possible
int z = r[1]: //just fine, z now holds the second element of the first "row" of baz

и, наконец, забавный бит мелочи; С A [X] эквивалентно * (A + X) , вы действительно можете использовать E.g. '3 [A] для доступа к четвертому элементу массива A. Я Ниже приведен совершенно законный код, и будет печать «B» четвертый символ строки FOO.

#include <stdio.h>

int main(int argc, char** argv) {
  char foo[] = "foobar";

  printf("%c\n", 3[foo]);

  return 0;
}