Класс, содержащий вложенные структуры.

[ezus]

Добрый день.

Возникла проблемы с использованием вложенных  в класс структурами.

Есть .h файл, содержащий описание класса ZFTAWIHEs, с вложенными структурами HEsProfile и HEsHouse.

Код:

// ZFTAWIHEs.h: interface for the ZFTAWIHEs class.
// #include "ZFTAWIHEs.h"
//////////////////////////////////////////////////////////////////////
class ZFTAWIHEs  
{
public:
	struct HEsProfile;
	struct HEsHouse;

private:
	CPtrArray	_houses;   	// HEsHouse*
	CPtrArray	_prfs;		// HEsProfile*

public:
	void addProfile( HEsProfile* prf );
	void setNewStatus( CString code, HEsProfile* prf, int newStatus );

	ZFTAWIHEs();
	virtual ~ZFTAWIHEs();

	//////////////////
public:
	struct HEsProfile
	{
		CString _code;
		CString _name;
		CMapStringToPtr _mapHes;	// CString->HEsHouse*
	};

	//////////////////
public:
	struct HEsHouse
	{
		CString _prfCode;
		CString _heCode;
	};
};

И есть другой класс ZFTADB, использующий эти структуры.

Код:

// ZFTADB.h: interface for the ZFTADB class.
// #include "ZFTADB.h"
//////////////////////////////////////////////////////////////////////
#include "ZFTAWIHEs.h"
////////
class ZFTADB  
{
public:
	bool saveHEsHouse( ZFTAWIHEs::HEsHouse* hou, bool bnew );
};

Проблема:
ZFTADB.h говорит
D:\............\ZFTADB.h(30) : error C2027: use of undefined type 'ZFTAWIHEs'
        D:\....\ZFTADB.h(28) : see declaration of 'ZFTAWIHEs'

Не могу ни за что уцепиться.
Может быть кто-нибудь видит в чем я туплю.

Спасибо.

[Алексей++]

ничего не менял, убрал только мусорное предопределение: всё компилится (с мусором тоже, впрочем, компилилось)

Код:

class ZFTAWIHEs  
{
	//////////////////
public:
	struct HEsProfile
	{
		CString _code;
		CString _name;
		CMapStringToPtr _mapHes;	// CString->HEsHouse*
	};

	//////////////////
public:
	struct HEsHouse
	{
		CString _prfCode;
		CString _heCode;
	};

private:
	CPtrArray	_houses;   	// HEsHouse*
	CPtrArray	_prfs;		// HEsProfile*

public:
	void addProfile( HEsProfile* prf );
	void setNewStatus( CString code, HEsProfile* prf, int newStatus );

	ZFTAWIHEs();
	virtual ~ZFTAWIHEs();

};

class ZFTADB  
{
public:
	bool saveHEsHouse( ZFTAWIHEs::HEsHouse* hou, bool bnew );
};

[Алексей++]

что-то недоговариваешь

[ezus]

что-то недоговариваешь

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

[ezus]

что-то недоговариваешь

Похоже, Да, не договариваю.

В первом .h файле есть #include "ZFTAProject.h, который приводит к циклическому вызову самого  .h файле, но они у меня защещены от повторного использования.

Я такие штуки не люблю и стараюсь, чтобы из не было.
И если требуется описать в .h файле указатедь на что-нибудь, я исползую что-то типа

Код:

class ZsUtWait;
struct FTAIProject;

Но в том и проблема, что с вложенными структурами и классами этот фокус у меня не проходит - на

Код:

class ZsUtWait;
struct ZsUtWait::Ququ;

она меня посылает ..., требуя описания ZsUtWait.

[Алексей++]

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

Впиши в начале всех *.h файлов строчку

#pragma once

А если по прежнему где-то циклические неудобства, то выноси проблему в файл *.cpp (то есть как обычно, как класс разносится по H и CPP)

[Dimka]

Но в том и проблема, что с вложенными структурами и классами этот фокус у меня не проходит - на

Код:
class ZsUtWait;
struct ZsUtWait::Ququ;
она меня посылает ..., требуя описания ZsUtWait.

Логично, ведь компилятор ещё не знает, что такое ZsUtWait.

Ты все участвующие в этом файлы с зависимостями между ними выложи.

[ezus]

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

Костыли-то костыли . Но я - старый хрыч, воспитанный на идеологии сверху-вниз, вот и описание мне легче воспринимать так - вначале сам объект, а потом уже его подробности. А так не понятно - к чему это море структур.
Вообще-то я начинал с кодов в абсолютных адресах, а там уж предопределение "что-где" не просто костыли - это фундаментные сваи, без них никуда. И появление подхода сверху-вниз было просто бальзам на израненную душу.

Впиши в начале всех *.h файлов строчку
#pragma once

Простите за невежество - на что это влияет?

А если по прежнему где-то циклические неудобства, то выноси проблему в файл *.cpp (то есть как обычно, как класс разносится по H и CPP)

Естественно, я так и делаю. Но когда член класса не указатель, приходится добавлять include в Н файл.

[ezus]

Но в том и проблема, что с вложенными структурами и классами этот фокус у меня не проходит - на

Код:
class ZsUtWait;
struct ZsUtWait::Ququ;
она меня посылает ..., требуя описания ZsUtWait.

Логично, ведь компилятор ещё не знает, что такое ZsUtWait.

Нелогично.

Для описания

ZsUtWait* ut;

не надо давать полное описание класса - достаточно предворительно определить

class ZsUtWait;

А для

ZsUtWait::Ququ* qu;

почему-то надо.
Где логика?

[Джон]

Логика в том, что ты пытаешься достать структуру Ququ, находящуюся внутри класса ZsUtWait (для справки: :: - scope operator), для этого необходимо в этом месте иметь доступ к содержимому этого класса.

Определение же "class ZsUtWait;" сообщает о том, что будет использоваться некий класс с именем ZsUtWait.

[Алексей++]

ezus, #pragma once - это для отключения повторного включения заголовка (если заголовок несколько раз засветился в других заголовках)

В любом случае, все заморочки решаются парой файлов H и CPP. Даже со вложенными классами

[Dimka]

Для описания

ZsUtWait* ut;

не надо давать полное описание класса - достаточно предворительно определить

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

А для

ZsUtWait::Ququ* qu;

почему-то надо.

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

[Алексей++]

ezus, вот, что тебе нужно сделать

Код:

// ZFTAWIHEs.h: interface for the ZFTAWIHEs class.
// #include "ZFTAWIHEs.h"
//////////////////////////////////////////////////////////////////////
#pragma once

struct HEsProfile
{
	CString _code;
	CString _name;
	CMapStringToPtr _mapHes;
};

struct HEsHouse
{
	CString _prfCode;
	CString _heCode;
};


class ZFTAWIHEs  
{
public:


	//добавить по вкусу
	typedef HEsProfile HEsProfile;
	typedef HEsHouse HEsHouse;



private:
	CPtrArray	_houses;   	// HEsHouse*
	CPtrArray	_prfs;		// HEsProfile*

public:
	void addProfile( HEsProfile* prf );
	void setNewStatus( CString code, HEsProfile* prf, int newStatus );

	ZFTAWIHEs();
	virtual ~ZFTAWIHEs();
};

[ezus]

вот, что тебе нужно сделать

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

[ezus]

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

Но ведь это все равно остается указателем, с т.зр. выделения памяти. А подробности понадобятся компилятору только в СС файле.

[ezus]

Логика в том, что ты пытаешься достать структуру Ququ, находящуюся внутри класса ZsUtWait (для справки: :: - scope operator), для этого необходимо в этом месте иметь доступ к содержимому этого класса.

Зачем? Это в любом случае просто указатель на структуру.

[Джон]

Зачем?

А зачем ты тогда говоришь это компилятору? Ты сам требуешь от него, чтобы он сделал указатель на структуру находящуюся ИМЕННО В КЛАССЕ ZsUtWait? Зачем ты приписываешь слева от типа структуры ещё и "ZsUtWait::"? Ведь тебе (говоря твоими словами) всё-равно какая это структура. Объяви её тогда просто void* qu; и всего делов.

Это в любом случае просто указатель на структуру.

Ещё раз - ТЫ ИСПОЛЬЗУЕШЬ ОПЕРАТОР "::" с указанием конкретной области видимости!!! Таким образом, в этом случае это уже не "просто указатель на структуру", а на структуру находящуюся внутри КОНКРЕТНОГО СУЩЕСТВУЮЩЕГО класса, и компилятор "воленс-неволенс" должен проверить наличие такого типа в классе ZsUtWait. В чём противоречие логике?

[ezus]

с указанием конкретной области видимости!!!

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

[Джон]

ezus, я тут на свежую голову подумал. Вот смотри так будет ещё проще:

1. При объявлении указателя:

ZsUtWait* ut;

компилятор ругается на незнание типа с именем ZsUtWait.

2. Чтоб решить проблему п.1. ты делаешь предобъявление (forward declaration) класса:

class ZsUtWait;

и всё замечательно, компилятор получает что хочет.

3. Теперь ты объявляешь указатель на структуру:

ZsUtWait::Ququ* qu; (с точки зрения компилятора в данный момент эта строчка эквивалентна Ququ* qu;)

компилятор начинает искать тип Ququ и пытается обратиться к известной ему декларации типа ZsUtWait в п.2. но ничего там ессно не находит. Поэтому он сообщает об ошибке.

[Dale]

ZsUtWait::Ququ* qu; (с точки зрения компилятора в данный момент эта строчка эквивалентна Ququ* qu;)

Вот что по этому поводу говорит Страуструп:

Указатель на член класса B можно присваивать указателю на член того же типа класса D при условии, что D является прямым или непрямым производным класса B, и однозначно описан как производный в части public ($$R.10.1.1).

Фактически ZsUtWait::Ququ* и Ququ* - разные типы. Для того, чтобы получить адрес ZsUtWait::Ququ, компилятору должна быть известна вся структура ZsUtWait.

(Прошу прощения за цитирование Страуструпа).

[Джон]

Ну наследование здесь вобще не при чём. Просто автор так спроектировал свои типы данных, что скрыл Ququ внутри типа ZsUtWait. Причём здесь производные классы?

Фактически ZsUtWait::Ququ* и Ququ* - разные типы.

Фактически - конечно. Но я специально оговорился, что это с точки зрения компилятора и именно в данный момент. Ququ - для компилятора неизвестный тип данных, он может его искать среди стандартных типов, среди уже известных ему типов, либо с использованием оператора :: в указаном пространстве. Я привёл сравнение с Ququ* qu;, чтобы показать, что именно тип Ququ неизвестен компилятору. Ну или совсем как в детсаде:

1. Мне нужен указатель на тип Ququ. Я его объявляю:

Ququ* qu;

2. Компилятор ругается - он такого типа не знает.

3. Ах да, действительно! Ququ находится внутри пространства имён класса ZsUtWait. Значит надо ему указать, где искать этот тип:

ZsUtWait::Ququ* qu;

4. Посольку у нас нет содержимого типа ZsUtWait, а только предобъявление (если так на русский можно перевести forward declaration), компилятор не находит Ququ.

[Dale]

Ну наследование здесь вобще не при чём. ... Причём здесь производные классы?

Здесь речь о том, что ZsUtWait::Ququ* совместим либо с другим ZsUtWait::Ququ*, либо с неким SomeClass::Ququ* при условии, что SomeClass наследует от ZsUtWait.

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

[Джон]

Dale, ну ты всё правильно говоришь, но каким боком это относится к данной теме? Вот я чего не пойму. Посмотри на код в топиках выше. Там нет никаких наследований, а есть класс с вложенными в него структурами. В приведённой же тобой цитате говорится о производных классах. А ezus пытается разобраться:

Для описания

ZsUtWait* ut;

не надо давать полное описание класса - достаточно предворительно определить

class ZsUtWait;

А для

ZsUtWait::Ququ* qu;

почему-то надо.
Где логика?

[Джон]

Кстати, ezus, два момента по ходу дела:

1.

Ведь предопределения - это костыли ))

Нифга подобного. Это стандартный приём, более того в некоторых случаях даже необходимый и/или предпочтительный. Например, если в одном h-файле определены два класса, которые ссылаются (используют поля данных) друг на друга. Или, например, если в объявлении полей данных класса использутся только указатели на другой класс, то forward declaration этого другого класса предпочтительней include. В этом случае компиляция и отладчик работают быстрей, немного, но быстрей.

2. Если уж у тебя вложенные структуры используются за пределами класса ZsUtWait как public, то может есть смысл вынести их из него? Какая необходимость их "прятать"?

[Dale]

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

[Джон]

Хмммм... Я это явно из цитаты не понял. Насколько я понял, в ней речь идёт о присваивании указателей на члены производных типов. А не о декларации указателей. Указатель в любом случае не будет зависеть от структуры класса, а будет равен всегда 32 битам (на 32 разрядных машинах). Теоретически можно делать так:

void * uq;

и в дальнейшем, где Ququ уже видна, использовать доступ к членам Ququ с помощью приведения типа:

((ZsUtWait::Ququ*)uq)->...

грязно, но можно. На суть указателя при объявлении это никак не влияет. Единственное требование при объявлении - тип должен находится в области видимости на данном этапе компиляции.

Ну и уж чтобы совсем исключить классы и иже с ними производные. Аналогичная проблема возникнет в более понятном случае:

Код:

namespace ZsUtWait
{
	class Ququ {};
}

void MyFunc()
{
	Ququ *p1 = NULL; // ошибка
	ZsUtWait::Ququ *p = NULL; // всё в порядке
}

[Алексей++]

Джон, если приходится использовать приведение от void* , это верный признак того, что что-то не так И пусть даже при этом будет компилиться на 3 секунды дольше

[Dale]

Хмммм... Я это явно из цитаты не понял.

Да, там действительно эти "производные" лишь запутали дело. На самом деле суть сказанного в том, что указатель на член класса некоторого типа и указатель на этот тип - разные вещи, поэтому трактуются компилятором по-разному. Указатель на член класса совместим только с таким же указателем. А поскольку производный класс обычно может выступать в качестве базового, то и его за компанию притулили в цитату, что в данном случае только запутывает.

Джон, если приходится использовать приведение от void* , это верный признак того, что что-то не так И пусть даже при этом будет компилиться на 3 секунды дольше

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

[Джон]

Джон, если приходится использовать приведение от void* , это верный признак того, что что-то не так И пусть даже при этом будет компилиться на 3 секунды дольше

Кто говорил, что приходится это использовать?      

Читаем внимательно:

Теоретически можно делать так

грязно, но можно.

зы Ещё раз, приведённый "грязный" пример призван показать независимость указателя от природы типа.

[Джон]

Ща порылся в Страуструпе:

Указатель на член можно получить, применив операцию взятия адреса & к полностью уточненному имени члена класса, например, &class_name::member_name. Чтобы описать переменную типа "указатель на член класса X", надо использовать описатель вида X::*.

   "Просто и убедительно, в стиле чемпиона!" (с)