Размещение звездочки в объявлениях указателей

Недавно я решил, что мне просто нужно наконец выучить C / C ++, и есть одна вещь, которую я действительно не понимаю в указателях или, точнее, в их определении.

Как насчет этих примеров:

1. int* test;
2. int *test;
3. int * test;
4. int* test,test2;
5. int *test,test2;
6. int * test,test2;

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

Второй набор примеров немного сложнее. В случае 4 и test, и test2 будут указателями на int, тогда как в случае 5 только test является указателем, а test2 - «реальным» int. А как насчет случая 6? То же, что и в случае 5?

4, 5 и 6 - это одно и то же, только test - это указатель. Если вам нужны два указателя, вы должны использовать:

int *test, *test2;

Или еще лучше (чтобы все было понятно):

int* test;
int* test2;

Пробелы вокруг звездочек значения не имеют. Все три означают одно и то же:

int* test;
int *test;
int * test;

" int *var1, var2" - это злой синтаксис, который предназначен только для того, чтобы запутать людей, и его следует избегать. Он расширяется до:

int *var1;
int var2;

Многие руководства по кодированию рекомендуют объявлять только одну переменную в каждой строке . Это позволяет избежать путаницы, которая была у вас до того, как задать этот вопрос. Большинство программистов на C ++, с которыми я работал, похоже, придерживаются этого.

Я знаю немного в сторону, но кое-что, что я нашел полезным, - это читать объявления задом наперед.

int* test;   // test is a pointer to an int

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

int* const test; // test is a const pointer to an int

int const * test; // test is a pointer to a const int ... but many people write this as  
const int * test; // test is a pointer to an int that's const

Используйте «Правило спирали по часовой стрелке» для облегчения анализа объявлений C / C ++;

Необходимо выполнить три простых шага:

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

   [X] или [] : размер массива X ... или неопределенный размер массива ...

   (type1, type2): функция передает type1 и возвращает type2 ...

   *: указатель (ы) на ...

2. Продолжайте делать это по спирали / по часовой стрелке, пока все жетоны не будут закрыты.
3. Всегда сначала разрешайте все, что указано в скобках!

Кроме того, объявления должны быть по возможности в отдельных выражениях (что верно в подавляющем большинстве случаев).

Как уже упоминалось, 4, 5 и 6 одинаковы. Часто люди используют эти примеры, чтобы аргументировать, что *переменная принадлежит переменной, а не типу. Хотя это вопрос стиля, есть некоторые споры о том, следует ли вам думать и писать так:

int* x; // "x is a pointer to int"

или так:

int *x; // "*x is an int"

FWIW Я нахожусь в первом лагере, но причина, по которой другие приводят аргумент в пользу второй формы, заключается в том, что она (в основном) решает эту конкретную проблему:

int* x,y; // "x is a pointer to int, y is an int"

что потенциально вводит в заблуждение; вместо этого вы бы написали либо

int *x,y; // it's a little clearer what is going on here

или если вам действительно нужны два указателя,

int *x, *y; // two pointers

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

#include <type_traits>

std::add_pointer<int>::type test, test2;

В 4, 5 и 6 testвсегда есть указатель, а test2не указатель. Пробелы (почти) никогда не имеют значения в C ++.

Смысл C в том, что вы объявляете переменные так, как вы их используете. Например

char *a[100];

говорит, что *a[42]это будет char. И a[42]указатель на символ. Итак, aэто массив указателей на символы.

Это потому, что авторы исходного компилятора хотели использовать один и тот же синтаксический анализатор для выражений и объявлений. (Не очень разумная причина для выбора языкового дизайна)

На мой взгляд, ответ - ОБА, в зависимости от ситуации. Вообще, IMO, лучше ставить звездочку рядом с именем указателя, а не с типом. Сравните, например:

int *pointer1, *pointer2; // Fully consistent, two pointers
int* pointer1, pointer2;  // Inconsistent -- because only the first one is a pointer, the second one is an int variable
// The second case is unexpected, and thus prone to errors

Почему второй случай противоречив? Потому что, например, int x,y;объявляются две переменные одного и того же типа, но этот тип упоминается в объявлении только один раз. Это создает прецедент и ожидаемое поведение. И int* pointer1, pointer2;это несовместимо с этим, потому что он объявляется pointer1как указатель, но pointer2является целочисленной переменной. Очевидно, что он подвержен ошибкам, и, следовательно, его следует избегать (поставив звездочку рядом с именем указателя, а не с типом).

Однако есть некоторые исключения, когда вы не сможете поставить звездочку рядом с именем объекта (и там, где это имеет значение, где вы его поместите) без получения нежелательного результата - например:

MyClass *volatile MyObjName

void test (const char *const p) // const value pointed to by a const pointer

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

void* ClassName::getItemPtr () {return &item;} // Clear at first sight

Я бы сказал, что первоначальное соглашение заключалось в том, чтобы поставить звездочку на стороне имени указателя (правая часть объявления

• в языке программирования c Денниса М. Ритчи звезды находятся в правой части объявления.

• посмотрев исходный код Linux на https://github.com/torvalds/linux/blob/master/init/main.c, мы увидим, что звездочка также находится справа.

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

Указатель является модификатором типа. Лучше читать их справа налево, чтобы лучше понять, как звездочка изменяет тип. 'int *' можно читать как «указатель на int». В нескольких объявлениях вы должны указать, что каждая переменная является указателем, иначе она будет создана как стандартная переменная.

1,2 и 3) Тест имеет тип (int *). Пробелы не имеют значения.

4,5 и 6) Тест имеет тип (int *). Test2 имеет тип int. Опять же пробелы несущественны.

Эта головоломка состоит из трех частей.

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

На этапе предварительной обработки исходный текст разбивается на последовательность токенов - идентификаторы, знаки препинания, числовые литералы, строковые литералы и т. Д. Эта последовательность токенов позже анализируется на предмет синтаксиса и значения. Токенизатор является «жадным» и построит максимально длинный допустимый токен. Если вы напишете что-то вроде

inttest;

токенизатор видит только два токена - идентификатор, inttestза которым следует знак препинания ;. На intэтом этапе он не распознается как отдельное ключевое слово (это происходит позже в процессе). Итак, чтобы строка считалась объявлением целого числа с именем test, мы должны использовать пробелы для разделения токенов идентификаторов:

int test;

Этот *символ не является частью какого-либо идентификатора; это отдельный токен (пунктуатор) сам по себе. Итак, если вы напишете

int*test;

компилятор видит 4 отдельных лексем - int, *, test, и ;. Таким образом, пробелы не важны в объявлениях указателей, и все

int *test;
int* test;
int*test;
int     *     test;

интерпретируются одинаково.

Вторая часть головоломки - это то, как объявления на самом деле работают в C и C ++ ¹ . Объявления разбиты на две основные части - последовательность спецификаторов декларации ( спецификаторы класса хранения, спецификаторы типа, квалификаторы типа и т. Д.), За которой следует список (возможно, инициализированных) деклараторов, разделенных запятыми . В декларации

unsigned long int a[10]={0}, *p=NULL, f(void);

в декларации спецификаторы unsigned long intи declarators являются a[10]={0}, *p=NULLи f(void). Декларатор вводит имя объявляемой вещи ( a, pи f) вместе с информацией о массиве, указателе и функции этой вещи. С декларатором также может быть связанный инициализатор.

Тип a- «10-элементный массив unsigned long int». Этот тип полностью определяется комбинацией спецификаторов объявления и декларатора, а начальное значение указывается с помощью инициализатора ={0}. Точно так же типом pявляется «указатель на unsigned long int», и снова этот тип определяется комбинацией спецификаторов объявления и декларатора и инициализируется значением NULL. И по той же причине тип f"возврат функции unsigned long int".

Это ключевой момент - нет спецификатора типа "указатель на" , так же как нет спецификатора типа "массив из", точно так же, как нет спецификатора типа "возвращающий функцию". Мы не можем объявить массив как

int[10] a;

потому что операнд []оператора aне int. Аналогично в декларации

int* p;

операнд *is p, not int. Но поскольку оператор косвенного обращения является унарным, а пробелы не важны, компилятор не будет жаловаться, если мы напишем его таким образом. Однако он всегда интерпретируется как int (*p);.

Следовательно, если вы напишете

int* p, q;

операнд *is p, поэтому он будет интерпретирован как

int (*p), q;

Таким образом, все

int *test1, test2;
int* test1, test2;
int * test1, test2;

сделайте то же самое - во всех трех случаях test1является операндом *и, следовательно, имеет тип "указатель на int", а test2имеет тип int.

Заявители могут быть очень сложными. У вас могут быть массивы указателей:

T *a[N];

у вас могут быть указатели на массивы:

T (*a)[N];

у вас могут быть функции, возвращающие указатели:

T *f(void);

у вас могут быть указатели на функции:

T (*f)(void);

у вас могут быть массивы указателей на функции:

T (*a[N])(void);

у вас могут быть функции, возвращающие указатели на массивы:

T (*f(void))[N];

у вас могут быть функции, возвращающие указатели на массивы указателей на функции, возвращающие указатели на T:

T *(*(*f(void))[N])(void); // yes, it's eye-stabby.  Welcome to C and C++.

и тогда у вас есть signal:

void (*signal(int, void (*)(int)))(int);

который читается как

       signal                             -- signal
       signal(                 )          -- is a function taking
       signal(                 )          --   unnamed parameter
       signal(int              )          --   is an int
       signal(int,             )          --   unnamed parameter
       signal(int,      (*)    )          --   is a pointer to
       signal(int,      (*)(  ))          --     a function taking
       signal(int,      (*)(  ))          --       unnamed parameter
       signal(int,      (*)(int))         --       is an int
       signal(int, void (*)(int))         --     returning void
     (*signal(int, void (*)(int)))        -- returning a pointer to
     (*signal(int, void (*)(int)))(   )   --   a function taking
     (*signal(int, void (*)(int)))(   )   --     unnamed parameter
     (*signal(int, void (*)(int)))(int)   --     is an int
void (*signal(int, void (*)(int)))(int);  --   returning void
    

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

Одна вещь, на которую следует обратить внимание - constможно изменить как тип указателя, так и тип указателя:

const int *p;  
int const *p;

Оба из вышеперечисленных объявляются pкак указатель на const intобъект. Вы можете написать новое значение, чтобы pоно указывало на другой объект:

const int x = 1;
const int y = 2;

const int *p = &x;
p = &y;

но вы не можете писать в объект, на который указывает:

*p = 3; // constraint violation, the pointed-to object is const

Однако,

int * const p;

объявляется pкак constуказатель на неконстантный int; вы можете написать то, на что pуказывает

int x = 1;
int y = 2;
int * const p = &x;

*p = 3;

но вы не pможете указать на другой объект:

p = &y; // constraint violation, p is const

Это подводит нас к третьей части головоломки - почему декларации структурированы именно так.

Предполагается, что структура объявления должна точно отражать структуру выражения в коде («объявление имитирует использование»). Например, предположим, что у нас есть массив указателей на intnamed ap, и мы хотим получить доступ к intзначению, на которое указывает i'th элемент. Мы получили бы доступ к этому значению следующим образом:

printf( "%d", *ap[i] );

Выражение *ap[i] имеет тип int; таким образом, объявление apзаписывается как

int *ap[N]; // ap is an array of pointer to int, fully specified by the combination
            // of the type specifier and declarator

Декларатор *ap[N]имеет ту же структуру, что и выражение *ap[i]. Операторы *и []ведут себя в объявлении так же, как и в выражении - []имеют более высокий приоритет, чем унарный *, поэтому операнд *равен ap[N](он анализируется как *(ap[N])).

В качестве другого примера предположим, что у нас есть указатель на массив intnamed, paи мы хотим получить доступ к значению i'th элемента. Мы бы написали это как

printf( "%d", (*pa)[i] );

Тип выражения (*pa)[i]- int, поэтому объявление записывается как

int (*pa)[N];

Опять же, применяются те же правила приоритета и ассоциативности. В этом случае мы не хотим разыменовывать i'th элемент pa, мы хотим получить доступ к i' th элементу, на который pa указывает , поэтому мы должны явно сгруппировать *оператор с pa.

Операторы *, []и ()являются частью выражения в коде, поэтому все они являются частью декларатора в объявлении. Декларатор сообщает вам, как использовать объект в выражении. Если у вас есть такое объявление int *p;, это говорит вам, что выражение *pв вашем коде даст intзначение. В расширении он сообщает вам, что выражение pдает значение типа «указатель на int» или int *.

Итак, что о таких вещах , как литые и sizeofвыражения, где мы используем такие вещи , как (int *)или sizeof (int [10])или тому подобные? Как мне прочитать что-то вроде

void foo( int *, int (*)[10] );

Там нет описателя, не является *и []операторами , изменяющих типа напрямую?

Что ж, нет - есть еще декларатор с пустым идентификатором (известный как абстрактный декларатор ). Если мы представим пустой идентификатор с символом X, то мы можем читать эти вещи , как (int *λ), sizeof (int λ[10])и

void foo( int *λ, int (*λ)[10] );

и они ведут себя точно так же, как и любое другое объявление. int *[10]представляет собой массив из 10 указателей, а int (*)[10]представляет собой указатель на массив.

А теперь самоуверенная часть этого ответа. Мне не нравится соглашение C ++ об объявлении простых указателей как

T* p;

и считают это плохой практикой по следующим причинам:

1. Это не соответствует синтаксису;
2. Это вносит путаницу (о чем свидетельствует этот вопрос, все дубликаты этого вопроса, вопросы о значении T* p, q;, все дубликаты этих вопросов и т. Д.);
3. Это внутренне непротиворечиво - объявление массива указателей T* a[N]асимметричным с использованием (если вы не привыкли писать * a[i]);
4. Его нельзя применять к типам «указатель на массив» или «указатель на функцию» (если только вы не создаете определение типа только для того, чтобы можно было T* pаккуратно применить соглашение, а это… нет );
5. Причина этого - «это подчеркивает указатель на объект» - надумана. Его нельзя применять к типам массивов или функций, и я думаю, что эти качества так же важно подчеркнуть.

В конце концов, это просто указывает на путаницу в размышлениях о том, как работают системы типов двух языков.

Есть веские причины декларировать товары отдельно; работа над плохой практикой ( T* p, q;) не входит в их число. Если вы правильно напишете свои деклараторы ( T *p, q;), вы вряд ли запутаетесь.

Я считаю, что это сродни намеренному написанию всех ваших простых forциклов как

i = 0;
for( ; i < N; ) 
{ 
  ... 
  i++ 
}

Синтаксически верный, но сбивающий с толку, а намерение может быть неправильно истолковано. Однако это T* p;соглашение укоренилось в сообществе C ++, и я использую его в своем собственном коде C ++, потому что согласованность всей базы кода - это хорошо, но каждый раз, когда я это делаю, у меня начинает чесаться.

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

Например:

int const bla;

Константа применяется к слову "int". То же самое и со звездочками указателей, они применяются к ключевому слову слева от них. А собственно имя переменной? Ага, это декларируется тем, что от него осталось.