double (A::*p)[10] = &A::x, не?

Шаман! Спасибо;-)

А на второй вопрос? Как на третий элемент указатель взять?

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

	double A::* p2 = (double A::*)16;
...
error: invalid cast from type ‘int’ to type ‘double A::*’

(&A::x)[3] ? У меня компилятора под рукой нет, я из головы пишу.

А насильно кастовать к указателю на член нельзя, ЕМНИП.

Тут вон целая статья по этому поводу:

http://publib.boulder.ibm.com/infocenter/lnxpcomp/v8v101/index.jsp?topic=/com...

error: invalid types ‘double (A::*)[10][int]’ for array subscript

Спасибо, но там все банально.

Тогда, наверное, (*(&A::x))[3], но что-то я перестаю понимать, зачем это нужно. Как там звучит настоящий вопрос?

Ну так из того следует:

class A {
public:
    double b[10];
};


typedef double (A::*bptr_t)[10];

int main() {
    A a;
    a.b[0] = 42;

    bptr_t c = &A::b;

    cout << "42: " << (a.*c)[0] << endl;

    return 0;
}

Или не оно?

Тогда, наверное, (*(&A::x))[3]

error: invalid use of ‘unary *’ on pointer to member

зачем это нужно. Как там звучит настоящий вопрос?

Так и звучит. У меня есть некая заморочная хитропараметризованная функция, которая принимает через аргумент шаблона указатель на член класса (скажем типа double). Беда в том, что поле на которое передаем указатель может быть не просто полем, но и элементом массива.

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

Да, но это ответ тока на первый вопрос (и taigunner на него уже ответил;-)). Я не там скобочку ставил.

error: invalid use of ‘unary *’ on pointer to member

А, ну да... нужно же объект указать:

double (A::*parr)[10] = &A::x; double elt = (obj->*parr)[3];

До этого я сам додумался, интересно как без объекта (указатель на член, а не просто указатель;-)))).

Ну я поэтому и спрашивал, как звучит настоящий вопрос. ЕМНИП, указатель на член - это смещение от начала объекта, он не имеет смысла без указателя на объект.

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

*(T*)((char*)&a+offset)

a.*p

Непонятно почему нельзя смещение (число в байтах) кастануть к указателю на член

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

Ну для POD-типов то оно всегда смещение как смещение? Мне большего и не нужно.

Ну для POD-типов то оно всегда смещение как смещение?

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

А что собственно мешает использовать чистое смещение, в духе ptrdiff_t, и преобразование типов?

Ты всё равно по ходу без преобразований не выкрутишься, раз не хочешь передавать 2 параметра.

Да, для POD-типов оно _всегда_ смещение как смещение. В С++ спецификации даже чёткое определение POD-типов и POD-классов выделено.

Система загрузки данных из БД в память в MaNGOS, например, именно на этом факте построена. Куча строк типа «iiiiiiiccllllillllcccccc» и огромный кусок памяти, который из этих строк распарсивается по i -> int, c - char *, l -> long.

Есть offsetof, работает для таких типов (это к вопросу получения указателя на член и использования его без указателя на сам объект).

Крайне сомнительная идея (вообще UB), но всё-таки:

template <class C, typename M, typename T>
union beware {
    M C::* member;
    T* pointer;
};

#include <cstdint>

struct A {
    uint16_t x, y;
    double z[4];
};

#include <cstdio>

int main() {

    A a = {0x1234, 0x5678, {1., 2., 3., 4.}};

    {
        beware<A, uint16_t, uint8_t> u;
        u.member = &A::x;
        u.pointer += 1;
        printf("%x\n", a.*u.member);
        // 7812
    }

    {
        beware<A, uint8_t[], uint8_t> u;
        u.pointer = reinterpret_cast<uint8_t*>(2);
        printf("%x\n", (a.*u.member)[1]);
        // 56
    }

    {
        beware<A, double[4], double> u;
        u.member = &A::z;
        u.pointer += 1;
        printf("%f\n", (a.*u.member)[1]);
        // 3.000000
    }

}

Для ответа нужно быть действующим Си++-прогером :)

Звучит почти так же гордо, как быть «действующим вулканом»;-)

O! Я все время забываю про возможности юниона в качестве грязных хаков с кастингом, спасибо!

#include <stdio.h>

template<typename A, typename T> union FuckOffBiern{
    long offset;
    T A::* ptr;
};
template<typename A, typename T, int D> T A::* get_ptr(T (A::* ptr)[D], int i){
	FuckOffBiern<A,T> pu; pu.ptr = (T A::*)ptr;
	pu.offset += i*sizeof(T);
	return pu.ptr;
}

struct A{
	double x[10];
};

int main(){
      A a; a.x[2] = 123;
      printf("%g\n", a.*get_ptr(&A::x, 2) );
}

a.*get_ptr(&A::x, 2)

И чем такая запись лучше?

Действующие вулканы подсказывают, что правильно делать так: double *GetXRef() { return x; }

А ещё правильнее так: std::array<double> &GetXRef() {return x; }

http://gcc.gnu.org/onlinedocs/gcc-4.7.3/gcc/Optimize-Options.html#index-fstri..., http://gcc.gnu.org/bugs/#nonbugs, http://cellperformance.beyond3d.com/articles/2006/06/understanding-strict-ali..., http://blog.qt.digia.com/blog/2011/06/10/type-punning-and-strict-aliasing/, ну и http://stackoverflow.com/questions/2958633/gcc-strict-aliasing-and-horror-sto... :)

Ваша же идея, но другими словами

Дебажная сборка (без -O2, -O3) будет работать. Остальное — проблемы пользователей.

Как правильно, я написал выше.

Непонятно почему нельзя смещение (число в байтах) кастануть к указателю на член.

Потому что указатель на член кроме собственно самого смещения относительно начала структуры (класса) содержит еще указатель на сам объект, который передается при вызове функции-члена первым аргументом неявно как this, а при доступе к переменной члену используется как this->member_variable. Само по себе абстрактное смещение без конкретизации объекта бессмыссленно.

O! Я все время забываю про возможности юниона в качестве грязных хаков с кастингом, спасибо!

Поздравляю, ты только что сделал все необходимые приготовления для стрельбы по собственным яйцам! Работоспособность твоего костыля зависит от конкретного компилятора.

похоже, четыре звезды — это диагноз

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

А как насладиться этим извращением, то бишь практическое применение ?

ловля жуков в релизной сборке, потому что не ловятся в дебажной — традиционное народное развлечение

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

4.2, RTFM

И чем такая запись лучше?

Лучше чем что?

Действующие вулканы подсказывают, что правильно делать так: double *GetXRef() { return x; }

И какое это имеет отношение к указателю на член O_O? По такому коду однозначно детектится ООП головного мозга в терминальной стадии.

ЧТо сказать то хотели? В каком месте тут выстрелит выравнивание?

FuckOffBiern

Bjarne.

И, если уж ты пошел по пути грязных хаков, по крайней мере проверь, что A - это POD или standard layout, что там тебе больше подходит

Поскольку у нас не продакшен какой нить, а поделки для себя, то я могу гарантировать что там нет множественного виртуального наследования;-)

Лучше чем что?

(a.*p)[3]

По такому коду однозначно детектится ООП головного мозга в терминальной стадии.

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

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

struct A{ double x[10], y; };

void out(A& a, double A::*p){ printf("%g\n", a.*p); }

A * arr = ...;
for(...) out(arr[i], &A::y);
for(...) out(arr[i], get_ptr(&A::x, 4));

на самом деле все намного запутанней;-)

для тру

Вообще говоря, наприсанное — UB. На практике, начиная с -O2 GCC не постесняется переставить «pu.ptr = (T A::*)ptr;» и «pu.offset += i*sizeof(T);» местами

Теперь подумайте, что делать если известно поле класса, но еще неизвестен экземпляр (его просто нету пока).

По такому коду однозначно детектится профессиональный программист,

Ога, Ога. Меня всегда умиляла эта гордость от принадлежности к касте. Есть нюанс - в наших задачах про. программисты нафик ненужны, от них нет никакого толку. Все чему их учат крайне полезно и помогает при работе в большой команде, и очень мешает при разработке наукоемкого кода в группе из макс. трех человек. Когда приходит студент с задатками проф. программиста заложенными на младших курсах, его приходится долго бить по рукам что бы не писал геттеров/сеттеров, не сносил строку после каждой инструкции и скобки и т.д. Потому что в нашей области свой код читаешь в основном ты сам, гораздо реже такие же мудаки, но никогда проф. программисты. Потому что проф. программисты не знают нихера предметной области, и как бы не был отформатирован код, как бы не был он прекрасен с т.з. какононов проф. программирования, проф программист все равно в нем нихера не поймет. Это не браузеры писать, задачи очень специфические.

На практике - не переставляет, я проверял. Не надо думать что конпелятор дурней чем есть на самом деле.

Меня всегда умиляла эта гордость от принадлежности к касте.

Не надо тут. В тебе гордости от принадлежности к касте уж точно не меьше %)

я могу гарантировать

Famous last words #2

В тебе гордости от принадлежности к касте уж точно не меьше %)

Но я же не чморю проф. программистов за то что у них в игрульках лазерный луч в вакууме летит со скоростью 100м/c;-)

Но я же не чморю проф. программистов за то что у них в игрульках лазерный луч в вакууме летит со скоростью 100м/c;-)

Прогеры не при делах, это требование дизайнеров. Так красивее. И синий космос - тоже не к нам %)

Теперь подумайте, что делать если известно поле класса, но еще неизвестен экземпляр (его просто нету пока).

Вы должны мне новый парсер... В общем случае ответ — «шаблоны», но я подозреваю, что ваша проблема намного серьёзнее.

Ога, Ога. Меня всегда умиляла эта гордость от принадлежности к касте.

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

его приходится долго бить по рукам что бы не писал геттеров/сеттеров

Доооо. Надо писать (char *)(this) + &(A::x). В действительности, возле большинства геттеров/сеттеров (в частности, возле приведённого мной) надо писать комментарий вида «У меня необратимое поражение той части мозга, которая отвечает за правильную декомпозицию. Но я не настолько упорот чтобы выдёргивать указатели на члены».

В общем случае ответ — «шаблоны»

Шаблоны ответ универсальный, но не на этот вопрос как ни странно.

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

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

Сейчас задумываюсь, что вы путаете требования к кодинг стайлу с требованиями к производительности. Это довольно перпендикулярные вещи. В частности, разница между «double *GetXRef() { return x; }» и вашей конструкцией врядли измерима. А проблемы с dataflow, которые могут давать вполне измеримые значения, налицо.