Подтвердить что ты не робот

Является ли законным индексирование в структуру?

Независимо от того, как "плохо" используется код, и считая, что выравнивание и т.д. не является проблемой для компилятора/платформы, это undefined или нарушение поведения?

Если у меня есть такая структура: -

struct data
{
    int a, b, c;
};

struct data thing;

Является ли юридическим доступ к a, b и c как (&thing.a)[0], (&thing.a)[1] и (&thing.a)[2]?

В каждом случае, на каждом компиляторе и платформе я пробовал его, с каждой настройкой, которую я пробовал, он "работал". Я просто обеспокоен тем, что компилятор может не понимать, что b и вещь [1] - одно и то же, а магазины в "b" могут быть помещены в регистр и предмет [1] читает неправильное значение из памяти (например). В каждом случае я попробовал, но сделал все правильно. (Я понимаю, конечно, что не очень много)

Это не мой код; это код, с которым мне нужно работать, меня интересует, является ли этот код плохим или сломанным, поскольку разные влияют на мои приоритеты для его изменения:)

С тегами C и С++. Меня больше всего интересует С++, но и C, если он отличается, просто для интереса.

4b9b3361

ОТВЕТЫ

Ответ 1

Это незаконно 1. Это поведение Undefined в С++.

Вы принимаете элементы в массиве, но вот что говорит стандарт С++ (выделение мое):

[dcl.array/1]:... Объект типа массива содержит смежно выделено непустое множество N подобъекты типа T...

Но для членов нет такого смежного требования:

[class.mem/17]:...; Требования к выравниванию реализации могут привести к два смежных члены не будут назначаться сразу после друг друга...

В то время как вышеупомянутых двух кавычек должно быть достаточно, чтобы намекнуть, почему индексирование в struct, как вы это делали, не является определенным поведением по стандарту С++, давайте выбрать один пример: посмотрите на выражение (&thing.a)[2] - Что касается индекса оператор:

[expr.post//expr.sub/1]:Постфиксное выражение, за которым следует выражение в квадратных скобках, является постфиксное выражение. Одним из выражений должно быть glvalue типа "массив из Т" или указатель типа "указатель на Т", а другой быть prvalue неперечисленного перечисления или интегрального типа. В результате типа "Т". Тип "T" должен быть полностью определенным типом объекта .66 Выражение E1[E2] идентично (по определению) на ((E1)+(E2))

Копаем жирный текст вышеуказанной цитаты: относительно добавления интегрального типа к типу указателя (обратите внимание на то, что здесь).

[expr.add/4]: Когда выражение с интегральным типом добавляется или вычитается из указатель, результат имеет тип операнда указателя. Есливыражение P указывает на элемент x[i] объекта массив объект xс n элементами, выражения P + J и J + P (где J имеет значение J) указывают на (возможно, гипотетический) элемент x[i + j]если 0 ≤ i + j ≤ n; в противном случае, поведение undefined....

Обратите внимание на требование массива для предложения if; иначе в противном случае в приведенной выше цитате. Выражение (&thing.a)[2], очевидно, не подходит для предложения if; Следовательно, Undefined Поведение.

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

Некоторые жизнеспособные обходные пути (с определенным поведением) были предоставлены другими ответами.

Как справедливо указано в комментариях, [basic.lval/8], который был в моем предыдущее редактирование не применяется. Спасибо @2501 и @M.M.

1: см. @Barry ответ на этот вопрос только для одного юридического случая, когда вы можете получить доступ к thing.a через эту часть.

Ответ 2

Нет. В C это поведение undefined, даже если нет дополнения.

Вещь, которая вызывает поведение undefined, - это доступ за пределы доступа 1. Когда у вас есть скаляр (члены a, b, c в структуре) и пытайтесь использовать его как массив 2 для доступа к следующему гипотетическому элементу, вы вызываете поведение undefined, даже если это происходит быть другим объектом того же типа по этому адресу.

Однако вы можете использовать адрес объекта struct и вычислять смещение в конкретном члене:

struct data thing = { 0 };
char* p = ( char* )&thing + offsetof( thing , b );
int* b = ( int* )p;
*b = 123;
assert( thing.b == 123 );

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

1 (Цитируется по: ISO/IEC 9899: 201x 6.5.6 Аддитивные операторы 8)
 Если результат указывает один за последний элемент объекта массива, он не должен использоваться в качестве операнда унарного * оператора, который оценивается.

2 (Цитируется по: ISO/IEC 9899: 201x 6.5.6 Аддитивные операторы 7)
Для целей этих операторов указатель на объект, который не является элементом массив ведет себя так же, как указатель на первый элемент массива длиной один с тип объекта как его тип элемента.

Ответ 3

В С++, если вам это действительно нужно - создайте оператор []:

struct data
{
    int a, b, c;
    int &operator[]( size_t idx ) {
        switch( idx ) {
            case 0 : return a;
            case 1 : return b;
            case 2 : return c;
            default: throw std::runtime_error( "bad index" );
        }
    }
};


data d;
d[0] = 123; // assign 123 to data.a

он не только гарантированно работает, но и упрощается, вам не нужно писать нечитаемое выражение (&thing.a)[0]

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

struct data 
{
     int array[3];
     int &a = array[0];
     int &b = array[1];
     int &c = array[2];
};

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

struct data 
{
     int array[3];
     int &a() { return array[0]; }
     int &b() { return array[1]; }
     int &c() { return array[2]; }
};

Ответ 4

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

struct data {
  int a, b, c;
};

typedef int data::* data_int_ptr;

data_int_ptr arr[] = {&data::a, &data::b, &data::c};

data thing;
thing.*arr[0] = 123;

Ответ 5

В стандарте ISO C99/C11 запрет на использование в профсоюзе является законным, поэтому вы можете использовать это вместо указателей указателей на не-массивы (см. различные другие ответы).

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

С текущими версиями gcc и clang запись функции члена С++ с помощью switch(idx) для выбора члена будет оптимизирована для индексов постоянной времени компиляции, но создаст ужасные веткистые asm для индексов времени исполнения. Для этого нет ничего неправильного в switch(); это просто ошибка с пропущенной оптимизацией в текущих компиляторах. Они могут эффективно компилировать функцию Slava 'switch().

Решение/обходное решение для этого заключается в том, чтобы сделать это по-другому: дать вашему классу/структуре член массива и написать функции доступа для присоединения имен к определенным элементам.

struct array_data
{
  int arr[3];

  int &operator[]( unsigned idx ) {
      // assert(idx <= 2);
      //idx = (idx > 2) ? 2 : idx;
      return arr[idx];
  }
  int &a(){ return arr[0]; } // TODO: const versions
  int &b(){ return arr[1]; }
  int &c(){ return arr[2]; }
};

Мы можем посмотреть выход asm для разных прецедентов, в Godbolt explorer. Это полные функции системы x86-64 System V, при этом конечная инструкция RET опущена, чтобы лучше показать, что вы получите, когда они будут встроены. ARM/MIPS/что бы ни было похоже.

# asm from g++6.2 -O3
int getb(array_data &d) { return d.b(); }
    mov     eax, DWORD PTR [rdi+4]

void setc(array_data &d, int val) { d.c() = val; }
    mov     DWORD PTR [rdi+8], esi

int getidx(array_data &d, int idx) { return d[idx]; }
    mov     esi, esi                   # zero-extend to 64-bit
    mov     eax, DWORD PTR [rdi+rsi*4]

Для сравнения, ответ @Slava с использованием switch() для С++ делает asm таким же, как для индекса переменной runtime. (Код в предыдущей ссылке Godbolt).

int cpp(data *d, int idx) {
    return (*d)[idx];
}

    # gcc6.2 -O3, using `default: __builtin_unreachable()` to promise the compiler that idx=0..2,
    # avoiding an extra cmov for idx=min(idx,2), or an extra branch to a throw, or whatever
    cmp     esi, 1
    je      .L6
    cmp     esi, 2
    je      .L7
    mov     eax, DWORD PTR [rdi]
    ret
.L6:
    mov     eax, DWORD PTR [rdi+4]
    ret
.L7:
    mov     eax, DWORD PTR [rdi+8]
    ret

Это, очевидно, ужасно, по сравнению с версией Punisher, основанной на объединении на основе C (или GNU С++):

c(type_t*, int):
    movsx   rsi, esi                   # sign-extend this time, since I didn't change idx to unsigned here
    mov     eax, DWORD PTR [rdi+rsi*4]

Ответ 6

Это поведение undefined.

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

Существуют правила об aliasing (доступ к данным через два разных типа указателя), границы массивов и т.д.

Когда у вас есть переменная x, тот факт, что она не является членом массива, означает, что компилятор может предположить, что доступ к массиву без [] может изменить его. Поэтому он не должен постоянно перезагружать данные из памяти каждый раз, когда вы его используете; только если кто-то мог изменить его имя.

Таким образом, (&thing.a)[1] можно предположить, что компилятор не ссылается на thing.b. Он может использовать этот факт для изменения порядка чтения и записи на thing.b, что делает невозможным то, что вы хотите, чтобы не сделать то, что вы на самом деле сказали ему.

Классическим примером этого является отбрасывание const.

const int x = 7;
std::cout << x << '\n';
auto ptr = (int*)&x;
*ptr = 2;
std::cout << *ptr << "!=" << x << '\n';
std::cout << ptr << "==" << &x << '\n';

здесь вы обычно получаете компилятор, говорящий 7, затем 2!= 7, а затем два одинаковых указателя; несмотря на то, что ptr указывает на x. Компилятор принимает тот факт, что x является постоянным значением, чтобы не читать его, когда вы запрашиваете значение x.

Но когда вы берете адрес x, вы вынуждаете его существовать. Затем вы отбрасываете const и изменяете его. Таким образом, фактическое местоположение в памяти, где x было изменено, компилятор свободен на самом деле не читать его при чтении x!

Компилятор может получить достаточно умный способ выяснить, как избежать использования ptr для чтения *ptr, но часто это не так. Не стесняйтесь использовать и использовать ptr = ptr+argc-1 или некоторую путаницу, если оптимизатор становится умнее вас.

Вы можете предоставить пользовательский operator[], который получит правильный элемент.

int& operator[](std::size_t);
int const& operator[](std::size_t) const;

которые оба полезны.

Ответ 7

В С++ это в основном undefined поведение (это зависит от того, какой индекс).

Из [expr.unary.op]:

Для указателя арифметика (5.7) и сравнение (5.9, 5.10), объект, который не является элементом массива, адрес которого берется в этот способ считается принадлежащим массиву с одним элементом типа T.

Таким образом, выражение &thing.a считается ссылкой на массив из одного int.

Из [expr.sub]:

Выражение E1[E2] идентично (по определению) до *((E1)+(E2))

И из [expr.add]:

Когда выражение, которое имеет интегральный тип, добавляется или вычитается из указателя, результат имеет тип операнда указателя. Если выражение P указывает на элемент x[i] объекта массива x с элементами n, выражения P + J и J + P (где J имеет значение J) указывают на ( возможно-гипотетический) элемент x[i + j], если 0 <= i + j <= n; в противном случае поведение undefined.

(&thing.a)[0] отлично сформирован, потому что &thing.a считается массивом размера 1, и мы берем этот первый индекс. Это допустимый индекс.

(&thing.a)[2] нарушает предварительное условие, что 0 <= i + j <= n, так как мы имеем i == 0, j == 2, n == 1. Простое построение указателя &thing.a + 2 - это поведение undefined.

(&thing.a)[1] - интересный случай. Это фактически не нарушает ничего в [expr.add]. Нам разрешено взять указатель за концом массива - что бы это было. Здесь мы переходим к заметке в [basic.compound]:

Значение типа указателя, которое является указателем на конец объекта или мимо него, представляет собой адрес первый байт в памяти (1.7), занятый объектом53, или первый байт в памяти после окончания хранения занимаемых объектом, соответственно. [Примечание: указатель мимо конца объекта (5.7) не считается указывают на несвязанный объект типа объектов, который может быть расположен по этому адресу.

Следовательно, взятие указателя &thing.a + 1 определяется поведением, но разыменование его - undefined, потому что оно не указывает ни на что.

Ответ 8

Вот как использовать прокси-класс для доступа к элементам в массиве-члене по имени. Это очень С++ и не имеет преимуществ по сравнению с ref-возвращающими функциями доступа, кроме синтаксических предпочтений. Это перегружает оператор -> для доступа к элементам как к членам, поэтому, чтобы быть приемлемым, нужно как не нравится синтаксис accessors (d.a() = 5;), так и допускать использование -> с объектом без указателя. Я ожидаю, что это может также смутить читателей, не знакомых с кодом, поэтому это может быть скорее опрятный трюк, чем то, что вы хотите ввести в производство.

Структура Data в этом коде также включает в себя перегрузки для оператора индекса, для доступа к индексированным элементам внутри его элемента массива ar, а также к функциям begin и end для итерации. Кроме того, все они перегружены версиями non-const и const, которые, как мне казалось, необходимо включить для полноты.

Когда Data -> используется для доступа к элементу по имени (например: my_data->b = 5;), возвращается объект Proxy. Тогда, поскольку это Proxy rvalue не является указателем, его собственный оператор -> авто-цепной называется, который возвращает указатель на себя. Таким образом, объект Proxy создается и остается действительным во время оценки исходного выражения.

Конструирование объекта Proxy заполняет его 3 ссылочных элемента a, b и c в соответствии с указателем, переданным в конструкторе, который предполагается указывать на буфер, содержащий по меньшей мере 3 значения, тип которых задается как параметр шаблона T. Поэтому вместо использования названных ссылок, которые являются членами класса Data, это сохраняет память, заполняя ссылки в точке доступа (но, к сожалению, используя ->, а не оператор .).

Чтобы проверить, насколько оптимизирован оптимизатор компилятора, устраняет всю косвенность, введенную с помощью Proxy, приведенный ниже код содержит 2 версии main(). Версия #if 1 использует операторы -> и [], а версия #if 0 выполняет эквивалентный набор процедур, но только путем прямого доступа к Data::ar.

Функция Nci() генерирует целочисленные значения времени выполнения для инициализации элементов массива, что не позволяет оптимизатору просто подключать постоянные значения непосредственно к каждому вызову std::cout <<.

Для gcc 6.2, используя -O3, обе версии main() генерируют одну и ту же сборку (переключаются между #if 1 и #if 0 до сравнения первого main()): https://godbolt.org/g/QqRWZb

#include <iostream>
#include <ctime>

template <typename T>
class Proxy {
public:
    T &a, &b, &c;
    Proxy(T* par) : a(par[0]), b(par[1]), c(par[2]) {}
    Proxy* operator -> () { return this; }
};

struct Data {
    int ar[3];
    template <typename I> int& operator [] (I idx) { return ar[idx]; }
    template <typename I> const int& operator [] (I idx) const { return ar[idx]; }
    Proxy<int>       operator -> ()       { return Proxy<int>(ar); }
    Proxy<const int> operator -> () const { return Proxy<const int>(ar); }
    int* begin()             { return ar; }
    const int* begin() const { return ar; }
    int* end()             { return ar + sizeof(ar)/sizeof(int); }
    const int* end() const { return ar + sizeof(ar)/sizeof(int); }
};

// Nci returns an unpredictible int
inline int Nci() {
    static auto t = std::time(nullptr) / 100 * 100;
    return static_cast<int>(t++ % 1000);
}

#if 1
int main() {
    Data d = {Nci(), Nci(), Nci()};
    for(auto v : d) { std::cout << v << ' '; }
    std::cout << "\n";
    std::cout << d->b << "\n";
    d->b = -5;
    std::cout << d[1] << "\n";
    std::cout << "\n";

    const Data cd = {Nci(), Nci(), Nci()};
    for(auto v : cd) { std::cout << v << ' '; }
    std::cout << "\n";
    std::cout << cd->c << "\n";
    //cd->c = -5;  // error: assignment of read-only location
    std::cout << cd[2] << "\n";
}
#else
int main() {
    Data d = {Nci(), Nci(), Nci()};
    for(auto v : d.ar) { std::cout << v << ' '; }
    std::cout << "\n";
    std::cout << d.ar[1] << "\n";
    d->b = -5;
    std::cout << d.ar[1] << "\n";
    std::cout << "\n";

    const Data cd = {Nci(), Nci(), Nci()};
    for(auto v : cd.ar) { std::cout << v << ' '; }
    std::cout << "\n";
    std::cout << cd.ar[2] << "\n";
    //cd.ar[2] = -5;
    std::cout << cd.ar[2] << "\n";
}
#endif

Ответ 9

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

char index_data(const struct data *d, size_t index) {
  assert(sizeof(*d) == offsetoff(*d, c)+1);
  assert(index < sizeof(*d));
  char buf[sizeof(*d)];
  memcpy(buf, d, sizeof(*d));
  return buf[index];
}

Только для версии С++ вы, вероятно, захотите использовать static_assert, чтобы убедиться, что struct data имеет стандартный макет и, возможно, вместо этого исключает исключение из индекса.

Ответ 10

Это незаконно, но есть обходное решение:

struct data {
    union {
        struct {
            int a;
            int b;
            int c;
        };
        int v[3];
    };
};

Теперь вы можете индексировать v: