[c++] wtf is &*this?

o__O

p.s.: (не в тему) в качестве аргумента функции применял такое ссылку на указатель, но там это оправдано было:

QDataStream &operator>> (QDataStream &in, qfgui::BoundaryCondition *&bc)
{
    // на случай, если мы что-то не смогли считать до этого (размер массива)
    if(in.status() != QDataStream::Ok) {
        throw false;
    }
    bc = new BoundaryCondition(in);
    // а это на случай, если мы что-то не смогли считать сейчас
    if(in.status() != QDataStream::Ok) {
        throw false;
    }
    return in;
}

А если this внезапно NULL? C++ пройдет мимо этого?

struct A
{
	const A* p() { return &*this; }
};

int main()
{
	A* a = 0;
	a->p();
}

собирал g++ - не упало

так оно и без &* не падает

> так оно и без &* не падает

ес-но, проверялось именно &*this

Ну логично. Си тоже не валится от таких вещей, да и не должен.

Скорее не обязан падать, undefined behavior.

Впрочем зачем может пригодиться этот &*this так и непонятно. И не было бы так любопытно, если бы эта шиза не с такой систематичностью использовалась в том коде, с которым приходится мне иметь дело.

Напиши автору, спроси. Это как я понимаю BTK?

эм...а как this может быть NULL? откуда ты метод тогда вызываешь, батенька?

Добро пожаловать в наш дерьмовый мир обратно, батенька. http://codepad.org/7CvN2JTm

&*this is yet another reason for C++ to die.

> &*this is yet another reason for C++ to die.

из разряда:

/0 is yet another reason for C to die.

Да, воистину веревка достаточной длины, чтобы выстрелить себе в ногу.

Спасибо за ликбез, но это пипец

> Спасибо за ликбез, но это пипец

а подобное в С вас не смущает:

#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)

?

смущает, и?Что ЭТО делает?как у нулл может быть member?

> смущает, и?Что ЭТО делает?

вычисляет смещение поля структуры

как у нулл может быть member?

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

> как у нулл может быть member?

Молча. Адресная арифметика, только и всего. Никогда не стоит забывать, что Си — в достаточной мере низкоуровневый язык, ну а Си++ не далеко от него ушел.

компилятор натворил чё-то?

а как this может быть NULL

class A {
  A* foo(void) {
    return this;
  }
}

void baz(A* a) {
  A* b = a->foo();
}

Чему будет равен b в функции baz (и this в методе A::foo), когда кто-то в дебрях кода по ошибке вызовет baz(NULL) ?

>а подобное в С вас не смущает:
>#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)

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

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

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

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

да, когда «оказывается» - это плохо

> Перегрузка operator* и volatile явно не из этой оперы.

А перегрузка operator&()?

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

> Скорее не обязан падать, undefined behavior.

Это еще почему?! Вполне себе справедливая и соответствующая стандарту конструкция. this не отличается ничем от указателя другого любого типа.

&*this немного глупая конструкция ибо эквивалент обычного зиса $ cat test.cpp

#include <stdio.h>

class A
{
    public:
        size_t foo();
        size_t bar();
};

size_t A::foo()
{
    return (size_t)&*this;
}

size_t A::bar()
{
    return (size_t)this;
}

int main(int argc, char **argv)
{
    A a;
    printf("a.foo(): 0x%x\n", a.foo());
    printf("a.bar(): 0x%x\n", a.bar());
    printf("a      : 0x%x\n", &a);

    return 0;
}

$ ./a.out 
a.foo(): 0x31f1434f
a.bar(): 0x31f1434f
a      : 0x31f1434f

Потому что разыменование любого нулевого указателя влечет undefined behavior, не?

а подобное в С вас не смущает

Не смущает, но после C# полезно было вспомнить. Спасибо.

> Напиши автору, спроси. Это как я понимаю BTK?

Ух ох. Авторов след простыл. Что такое ВТК?

> А перегрузка operator&()?

Не, молчит греп. Инфа 100%.

И машинный код для обоих вариантов одинаковый.

из .text секции. просто этому методу передаётся 0 вместо this. Всё работает до тех пор, пока метод не сделает this->... что аналогично к обращению к любому не статичному полю класса. Вот тогда и segfault будет.

Именно по-этому статические методы можно использовать не имея экземпляра. Им этот this просто не передёт никто. И именно по этому они не могут обратится к обычным (не статическим) полям класса. У них этого this'a нету.

если * and & не перегружены, то ничего не будет. Если перегружены - привет.

Хотя мотивы автора не совсем понятны. Кастую namezys в тред.

А, и если такие пироги, то перегруженный operator* можно только у *this позвать. У this не получится.

> Что такое ВТК?

Я имел ввиду это: http://sourceforge.net/projects/btk/

а подобное в С вас не смущает

смущает: это UB, потому нормальные компиляторы определяют встроенный offsetof

> смущает: это UB, потому нормальные компиляторы определяют встроенный offsetof

да - оно есть в stddef.h, но некоторые( visual, tcc и т.д. ) компиляторы до сих определяют его через аналогичный макрос

> &*this

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

&*this; if (this) { xxxx; }

то компилятор сообразит, что this ненулевой и опустит проверку this на NULL перед xxxx;

Ситуация с перегрузкой операторов понятна - рассматривать ее не будем.

Попробуем Расмотреть только операторы по умолчанию. * фактически возвращает ссылку. О реализации ссылок не слова не говорится. Обычно, это тот жесамый указатель с сахаром (ну еще мелочь типа отложенной смерти временного объекта). На x86 нет не каких специальных правил обработки указателя. Но компилятор вполне может расчитывать, что там лежит валидный объект. И, возможна рахитектура, на которой такая работа может вызывать падение. Но это скорейиз области фантастики. Операция взятия адреса тут тоже «синтаксический сахар».

Вообще разыменование невалидной ссылки (по которой не лежит объект указанного типа) ошибочная операция. Для примера классика: взятие инта из char* буфера на архитектурах, учитывающих выравнивание типа. Но, опять же, это проявится при действии. А тут у нас синтаксический сахар.

Подэтожу: * компилятор тупо оптимизирует * развернет синтаксический сахар. Тут возможно падение на фантастический архитектуре, но я такой архитектуры не знаю

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

> Всё работает до тех пор, пока метод не сделает разыменование this чтобы обратиться к переменной-члену или виртуальному методу.

fixed

> смущает: это UB, потому нормальные компиляторы определяют встроенный offsetof

Это с точки зрения прикладной программы UB. А с точки зрения компилятора, UB превращается во вполне defined behavior. Поэтому если разработчики компилятора знают, что делают, то и могут использовать такие фичи.

что оно делает я догадался, просто смутило обращение к полю *(NULL).

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

• представляем, что у нас в NULL есть нужная структура;
• вычисляем адрес поля
• т.к. адрес этого поля вычислялся, считая, что структура начинается в 0, то таким образом мы получаем смещение поля

да?

С какого-то this == 0? Внутри использующего его метода он всегда не равен нулю, если только не сделали delete this перед этим.

> С какого-то this == 0? Внутри использующего его метода он всегда не равен нулю, если только не сделали delete this перед этим.

во-первых совсем не всегда, во-вторых delete this - этот самый this никоим образом не меняет

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

ты джавист штоле? this - это указатель, а указатель может указывать на что угодно. Если действительно джавист - добро пожаловать в ад c++!