Господа! Как сделать линейку объектов конструкторы бы которых запускались не с низу в верх ( от предка к потомкам ), а наоборот. Например если делать виртуальный метод, то происходит именно так.

Цитата

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

Я чего-то не понял, что это значит.

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

Код

class A { /* всякая всячина */ public:        A(); // конструтор предка }; class B : public A { ............... public:        B(); //конструтор потомка }; A::A() { /*инициализируем класс A */ } B::B() { /*инициализация B */    A(); //Конструктор класса A }

To RAN
Да, но более привычный синтаксис (по крайней мере, именно так - можно):

Код

B::B():A() { /*инициализация B */ }

vickr, по-моему ты не понял. Твой синтаксис запустит сначала конструктор A, а затем B. Надо то наоборот. Как?

В С++ виртуальных конструкторов не существует. Так же нельзя поменять порядок вызова конструкторов предков. Это данность языка и с этим ничего поделать нельзя. Исключением их правила являются виртуальные конструкторы VCL-библиотеки, но "тяжкое наследие" Object Pascal.
Что же касается самой необходимости его применения, скажи что ты хочешь и я скажу (может быть) что делать.
Да, и еще одно: виртуальные методы предназначены не для изменения порядка вызова, а для поддержки полиморфизма.

Я использую их пока для изменения порядка вызова. Например метод GetData для нового обьекта ( потомка ) будет вперед запущен, а потом ( если я укажу в методе ) вызову метод предка.
У меня в конструкторе предка стоит загрузка конкретной DLL и вся работа завязана на ее "хендле". Получается если я создам новый обьект и мне зохочеться указать название DLL другое, то облом? Не хочеться мне заводить еще одну загрузку DLL (Динамическую). А если даже и загрузить, то тогда что делать со старой?

если оформить так?

Код

int B::GetData() { ....////выполняем необходимые дейсвия return A::GetData(); }

Для метода GetData я так и делаю, а вот DENN как быть с конструктором?
Я бы хотел подключаться в другой DLL

В твоем случае, можно переписать объявление конструктора так:

Код

class A { public: A(char* LibraryName = "MyPreviousDLL")//по умолчанию загружается твоя основная { LoadLibrary(LibraryName); ....... } } class B : public A { } //сам код A var1; B var2("MyNewDll.dll");

Конечно метод не универсальный, но в твоем случае исправлений в коде почти не требуется.
Можно предложить и другие "хитрые способы", но суть не измениться - C++ нельзя изменить порядок вызова базовых кострукторов (это основа механизма наследования).

Цитата

Я использую их пока для изменения порядка вызова.

Для этого виртуальные методы не нужны совершенно. Способ предложенный DENN отлично используется и для не виртуальных методов.

Что касается конструктора DENN, ты абсолютно прав. Я так и сделаю Признаюсь, у меня была схожая мысль. Что-ж. Я ранее ( до того как задать вопрос ) делал так:
class A
{
public A()
{
LoadLibrary(LibraryName);
}
public A( newNameLibr) {LibraryName = newNameLibr; A();}

}
Таким образом:
B var ("MyName");
А как быть, если у меня наследник в третьем колене?
Есть A
Есть B::A с простым конструктором
и Есть С::B::A

Что же касается виртуальных методов, то если не сделаешь в потомке метод виртуальным, то при вызове B::GetData вызовиться GetData предка. Даже если он переопределен. Или я ошибаюсь....

Цитата

Что же касается виртуальных методов, то если не сделаешь в потомке метод виртуальным, то при вызове B::GetData вызовиться GetData предка. Даже если он переопределен. Или я ошибаюсь....

Чепуха, достаточно только в классе предке поставить virtual и класс потомок сможет его перегружать. Там писать virtual все не обязательно, но я всегда пишу, чтоб было наглядно видно - метод перегружен, но это дело вкуса.
Кстати, если бы даже метод не был виртуальным, то B::GetData() не мог бы всё равно вызывать метод предка A::GetData(), он бы вызывал свой метод. Так часто бывает с переменными, когда в двух классах, предке и потомке, одноимённые переменные, каждый будет видеть свою.
Смысл виртуальных методов не только в том, что ты можешь заменить функцию класса-предка на новую (именно заменить, а не вызвать раньше), но и в том, что даже если ты преобразуешь объект класса потомка к классу предка, тот всё равно будет видеть функцию класса потомка. Полиморфизм, батенька - методы, реально, принадлежат не классу, а объекту, созданному на его основе :

Код

class A { public: virtual int GetData() { return 1; } }; class B : public A{ public: virtual int GetData() { return 2; } int GetData2() { return 3; } }; в программе: A *class1; B *class2; class2 = new B; int x = class2->GetData(); //вызовет B::GetData() и вернёт 2 class1 = class2; x = class1->GetData(); //опять вызовет B::GetData() и вернёт 2 x = class1->GetData2(); //ОШИБКА, A::GetData2 не существует

Цитата(valex13 @ 10.6.2003, 05:33)

Что же касается виртуальных методов, то если не сделаешь в потомке метод виртуальным, то при вызове B::GetData вызовиться GetData предка. Даже если он переопределен. Или я ошибаюсь....

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

Код

class A { public   void func() {  cout << "funcA" << endl; }   virtual void vfunc { cout << "vfuncA" <<endl; } }; class B :public A { public   void func() {  cout << "funcB" << endl; }   virtual void vfunc { cout << "vfuncB" <<endl; } } A a; B b; a.func(); b.func(); a.vfunc(); b.vfunc(); A* pa = (A*)&b; //здесь проявляется различие между виртуальным и невиртуальным методом pa->func(); pa->vfunc();

результат паботы программы

Код

funcA funcB vfuncA vfuncB funcA vfuncB

А если вот такая ситуация:
Есть А и наследник В
Оба имеют один и тот же виртуальный метод OnCalc
Делаю так:
A *ab = new A();
B *bb = (A*)ab;
bb->OnCalc();
и вызывается OnCalc() объекта A.
А мне необходимо, чтобы вызывался метод объекта A?

Это сообщение отредактировал(а) valex13 - 11.6.2003, 08:12

Извините
bb->OnCalc(); - это описка.

Цитата(valex13 @ 11.6.2003, 08:10)

и вызывается OnCalc() объекта A. А мне необходимо, чтобы вызывался метод объекта A?

Вопрос не ясен.
Тебе нужен метод А, он и вызывается. Как ты и хотел

Цитата

Делаю так: A *ab = new A(); B *bb = (A*)ab; bb->OnCalc(); и вызывается OnCalc() объекта A.

Повторюсь, методы пренадлежат объекту, а не классу, чтоб метод или переменная принадлежали классу они должны быть объявлены как static. Поэтому как ab не крути, будет вызываться A::OnCalc(), ты ведь написал new A().
Есть такое понятие - vtable. vtable - это таблица, в которой храняться ссылки на все методы и переменные. И когда ты определяешь в предке метод, как виртуальный, то при его появлении в потомке просто меняется адрес в vtable (запутанно объяснил, надеюсь кто-нибудь что-нибудь понял).

Кстати, B* bb = (A*)ab; - совершенно бесполезная операция. ab итак типа A*, её незачем к A* преобразовывать, а bb типа B* и ab будет преобразована к B* в результате присвоения автоматически. Лично я в таких случаях преобразовываю явно, считаю что так правильнее:
B* bb = (B*)ab; //порядок

Цитата

преобразовываю явно, считаю что так правильнее: B* bb = (B*)ab;

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

B* bb = dynamic_cast<B*>(ab);

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

B* bb = static_cast<B*>(ab);