Void,да, ты меня обыграл ,но этот пример несерьезен(класс компелируется как "единое целое").

Цитата

Потому что Pics в точке инстанциирования std::list является неполным типом.

Вот это уже интереснее,но тогда вопрос:Зачем использывать такой синтаксис.В таком случае мы не выигрываем ни в чем,а можем ли мы выиграть при таком вообще???(Мне приходит в голову только когда надо структуру или класс с одинаковым именем и разным содержанием в разных классах создать)

Цитата(wpp @ 14.11.2005, 21:43)

Спасибо, Страуструп есть у меня. Объясняет он ужасно (IMHO). В кучу ничего из прочитанного собрать не удалось

Его сходу не поймешь.Для того чтобы его понять надо уже знать С++.

Цитата(nikitao @ 14.11.2005, 23:11)

Вот это уже интереснее,но тогда вопрос:Зачем использывать такой синтаксис.В таком случае мы не выигрываем ни в чем,а можем ли мы выиграть при таком вообще???(Мне приходит в голову только когда надо структуру или класс с одинаковым именем и разным содержанием в разных классах создать)

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

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

Код

template <class T> class Matrix {     T *p;     size_t rows_, cols_;     template <class T>     class Row {         T *p_;         size_t cols_;     public:         Row(T *p, size_t cols) : p_(p), cols_(cols) { }         T &operator [](size_t i) {             assert(i < cols_);             return p_[i];         }         const T &operator [](size_t i) const {             assert(i < cols_);             return p_[i];         }     }; public:     Matrix(size_t rows, size_t cols) : rows_(rows), cols_(cols),         p(new T[rows * cols]) { }     ~Matrix() {         delete[] p;     }     Row<T> operator [](size_t i) {         assert(i < rows_);         return Row<T>(p + i * cols_, cols_);     }     const Row<T> operator [](size_t i) const {         assert(i < rows_);         return Row<T>(p + i * cols_, cols_);     } };

Цитата(Void @ 14.11.2005, 19:36)

std::list<class Pics *> pics;

Вот уж не знал, что так можно делать. Есть три вопроса.
1) Наверное, это эквивалентно предварительному объявлению класса?
2) Это в стандарте?
3) Где же такая фича описывается? Не встречал даже у страуструпа.

Цитата(Chaos @ 15.11.2005, 12:37)

1) Наверное, это эквивалентно предварительному объявлению класса?

Похоже, что да. Компилируется и работает даже вот это:

Код

#include <list> int main() {     std::list<class A*> lst;     return lst.size(); }

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

Цитата(Chaos @ 15.11.2005, 12:37)

2) Это в стандарте?

Да. Точный пункт не укажу, упоминания равномерно размазаны по тексту.

Цитата(Chaos @ 15.11.2005, 12:37)

3) Где же такая фича описывается? Не встречал даже у Страуструпа.

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

На самом деле, это все обыкновенное следствие.
О котором можно догадаться видимо.
Класс и структура, являются производными от пространства имен
А значит в них же можно объвлять новые типы, как и в простом пространстве.
class Name;
Всегда являлся обявлением класса, а если есть объявление то можно использовать указатель на этот тип, но не сам тип.
Никто никогда не отменял этого

Код

class A; list<A *> B;

Видно что это ничем не отличается от

Код

list<class A *> B;

Более короткая запись.

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

Это сообщение отредактировал(а) Neitron - 15.11.2005, 14:48

Хочу добавить, что упоминание о вложенных структурах есть например в 10.8

Цитата(Neitron @ 15.11.2005, 11:49)

Код class A; list<A *> B; Видно что это ничем не отличается от Код list<class A *> B;

Не совсем. В глобальном скопе - да, а если это дело поместить внутрь класса, то в первом случае объявляется вложенный класс, а во втором случае компилятор считает, что class А - внешний. По крайней мере, MSVC так себя ведет. Так что, Void, твой пример из начала темы, работать не будет (компилироваться будет, но будут ошибки линкера - в MSVC!) - потому то классы A - разные.

Что касается примера со списком указателей на неполный класс - то принцип простой: инстационируется только то, то реально используется. Поэтому все будет компилироваться и работать до тех, пока не потребуется обратиться внутрь класса A.

Цитата(Earnest @ 16.11.2005, 00:29)

(компилироваться будет, но будут ошибки линкера - в MSVC!)

Не будут. Будут ошибки компиляции. Посыпаю пеплом голову

Код

#include <list> class A {     std::list<struct B*> lst; public:     struct B {         int x;         void foo() { }     };     A() { }     void foo() {         lst.push_back(new B);         lst.front()->foo();     } }; int main() {     A c;     c.foo(); }

Цитата

test.cpp(12) : error C2664: 'std::list<_Ty>::push_back' : cannot convert paramet er 1 from 'A::B *' to 'B *const &'         with         [             _Ty=B *         ]         Reason: cannot convert from 'A::B *' to 'B *const '         Types pointed to are unrelated; conversion requires reinterpret_cast, C- style cast or function-style cast test.cpp(13) : error C2027: use of undefined type 'B'         test.cpp(4) : see declaration of 'B' test.cpp(13) : error C2227: left of '->foo' must point to class/struct/union/gen eric type

Ну да, конечно, это я поторопилась и забыла, что был еще код, использующий это класс(подумала, что уже пробовали скомпилировать и получилось). Но точно знаю, что такой фокус не прокатывает внутри класса. А жаль.
Тоже самое для friend: если написать friend class BBB, то в локальном скопе класса не прокатит за предварительное объявление вложенного класса. А хотелось бы.
Интересно, это стандарт или частное поведение MSVC?

Цитата(Earnest @ 16.11.2005, 22:41)

Интересно, это стандарт или частное поведение MSVC?

Похоже, стандарт. Comeau ругается аналогичным образом. Вот только до конкретных указаний я все никак дойти не могу.

Void, интересную штуку ты откопал.

Код

#include <list> struct A {     std::list<struct B*> l; // компилится без проблем }; int main() { A a; }

А что это? В стандарте не нашел?

Цитата(LPBOY @ 7.12.2005, 13:36)

Void, интересную штуку ты откопал. Код #include <list> struct A {     std::list<struct B*> l; // компилится без проблем }; int main() { A a; } А что это? В стандарте не нашел?

А что тут странного. Обычная фишка языка. Компилятору всё-равно на что указатель, т.к. размер указателя для лубого класса имеет один и тот же размер. Суть в том, что толку от такой записи нет, если нет потом определения класса B.

Так дело в том что B неопределен!!
Почему тогда так не компилится?

Код

#include <list> struct A {     std::list<B*> l;  }; int main() { A a; }

Цитата(LPBOY @ 7.12.2005, 15:09)

Так дело в том что B неопределен!! Почему тогда так не компилится? Код #include <list> struct A {     std::list<B*> l;  }; int main() { A a; }

Прально, В же не определен.
А по поводу предыдущего куска, ты же нигде в коде не используешь B. Поэтому и предварительное объявление class B вполне нормально, но бесполезно, т.к. разыменовать указатель на B у тебя не получится.

LPBOY
Не забываем про существование объявлений.