&a[1] или a+1

Попробуй скомпилить так и так, и сравнить ассемблерный код. Мне кажется он будет одинаковый

Монописуально. Я всегда а+1 делаю.

Однофигственно.

Первый вариант понятнее.

Правильнее &a[1]. Потому что понятнее.

«а+1» в неуместных местах пишут фашисты от программирования.

по-моему, удобнее написать «a + i*j», нежели «&a[i*j]». Первая конструкция более понятна же.

Правильнее &a[1]. Потому что понятнее.

Ну-ну...

Не подкрепленные опытом галлюцинации

Хорош мычать, давай по существу

В C++ &( a[1]), в С a+1.

По существу, &a[1] - нагромождение знаков, а a+1 очевидная адресная арифметика.

Никакой разницы в читабельности нет.

&a[1] часто возникает, когда было готовое выражение, и к нему подставили &. a + 1 — когда набирали строчку с нуля.

Из которой не видно, что речь идет об адресе.

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

&a[1] часто возникает, когда было готовое выражение, и к нему подставили &. a + 1 — когда набирали строчку с нуля.

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

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

type a[DIM_ONE][DIM_TWO];
...
for( pa=a[1]; cond(pa); pa++ )
{
...
}

Бгг. Тебе не приходило в голову, что код существует годами, и над ним работают десятки человек? ЛОР такой ЛОР.

вообще от ситуации зависит. можно еще &1[a]

Адресная арифметика очевидный плюс C-подобных, я всегда пользовался вторым вариантом.

&a[1] - это взятие адреса первого элемента массива a

a+1 - это к чему-то прибавили 1

к чему-то

Всегда к указателю

Всегда считал что правильнее &a[1]

ну тогда пиши:

p = &a[p-a+1];

вместо:

p++;

Тебе не приходило в голову, что код существует годами, и над ним работают десятки человек?

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

Из которой не видно, что речь идет об адресе.

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

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

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

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

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

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

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

Это намного удобнее, чем вспоминать тип каждой конкретной переменной.

Это намного удобнее, чем вспоминать тип каждой конкретной переменной.

В массиве-то? Вы про Си вообще?

В массиве-то? Вы про Си вообще?

Если непонятно, о чем идет речь, см. исходное сообщение и тэги

Ну хорошо, относительно исходного сообщения и языка Си, чьи типы Вы затрудняетесь вспоминать?

a+1 — что это? Это адрес или значение? Вот это непонятно.

Имхо, дело привычки, ведь код

std::string buf="sometext";
std::cout<<buf+"anothertext"<<std::endl;

Речь о том что не понятно без контекста. a+1 в названии топика тоже бы трактовалось как плюс один к числовому значению «а» не будь оно противопоставлено &a[1].

Хороший синтаксис как пишется, так и читается. Поэтому предпочитаю &a[1].

Как там было... Если непосредственно из кода функции не ясно, является ли переменная указателем, «то его автор - идиот и быдлокодер» (c)

Если непосредственно из кода функции не ясно, является ли переменная указателем, «то его автор - идиот и быдлокодер» (c)

Если даже из кода функции непонятно, то ее автор - придурок, однозначно.

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

Поэтому не стоит специально усложнять себе жизнь.

a+1 — что это? Это адрес или значение? Вот это непонятно.

а++ - что это?

общие для всех правила кодирования

Подобные правила тяжело энфорсить.

Пиши код а не страдай ерундой.

от первого элемента?

Эти два представления эквивалентны. При этом второе (a+1) - ближе к тому, что на самом деле происходит при определении адреса второго элемента массива, а первое (&a[1]) - «синтаксический сахар», который тоже самое только естественнее, понятнее для человека. И сахар это вводят в языки, чтобы им пользовались, поэтому использовать второе представление стоит только, если на то есть особые причины.

по-моему, удобнее написать «a + i*j», нежели «&a[i*j]». Первая конструкция более понятна же.

Нужно найти адрес i*j-того элемента массива a.

Для этого сначала берём i*j-ый элемент массива a:

a[i*j]

&a[i*j]

А в a+ij кроются детали реализации.

А по мне второе понятнее: берем адрес массива и прибавляем к нему i*j

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

А контекст каждый волен придумать по вкусу? - потому что ваша конструкция в голом виде бесполезна.

&*some_vector.begin()

man front

Правильность определяется в зависимости от контекста. Где-то ты именно занимаешься адресной арифметикой, там понятнее a+1, в другом месте ты все считаешь в индексах и лишь в определенный момент тебе нужно получить адрес элемента с индексом, здесь уже более ожидаем первый вариант.

Всем спасибо.

угу, передай то что ты написал в ф-цию на С которая принимает указатель

Я знаю хороший способ детектить дебилов. Когда разговор идет о семантике языка, у которого есть стандарт, они предлагают:

Попробуй скомпилить так и так, и сравнить ассемблерный код.

угу, передай то что ты написал в ф-цию на С которая принимает указатель

сделать указатель из ссылки проще чем то, что написал ты

*(((void**)x)+1) или ((void**)x)[1]?