2012-06-12 4 views
1

У меня вопрос о чистых виртуальных функциях. Я не понимаю, как это работает, и когда нам нужно использовать чистые виртуальные функции. Это пример того, что я не понимаю:чистая виртуальная функция, как она работает

file.h 

class A 
{ 
public : 
      A(); 
      ~A(); 

      virtual void func1(void) = 0; 
      virtual UINT32 func2(void) = 0; 
      UINT32 initialize(void) = 0; 
} 


file.cpp 

UINT32 A:initialize (void) 
{ 
      func1(); 
      func2(); 
      return (result); 
} 

Может кто-нибудь объяснить в деталях, что на самом деле делает этот пример, и что в результате? Я очень ценю вашу помощь и знания. Большое спасибо.

+0

Это не скомпилируется. Вы уверены, что не имеете в виду 'UINT32 result = func2();' вместо просто 'func2();' в середине функции инициализации A: – Lalaland

+0

Да, я думаю, что это ошибка. Ты прав. Спасибо .. :) –

+0

Возможный дубликат [чистая виртуальная функция с реализацией] (http://stackoverflow.com/questions/2089083/pure-virtual-function-with-implementation) –

ответ

1

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

Основная цель виртуальных функций - полиморфизм.

Класс A определяет два чистых виртуальных метода, и initialize называет их. Это позволяет коду в программе инициализировать что-то типа A, не зная подкласса. Может быть много подклассов A, и каждый может делать что-то немного по-другому в пределах func1() и func2(). Поскольку код, который знает только о A, иногда инициализирует объекты разных типов через A, A можно назвать полиморфным типом.

class B : public A { 
    void func1() { std::cout << "B::func1" << std::endl; } 
    UINT32 func2() { return 1; } 
}; 

class C : public A { 
    void func1() { std::cout << "C::func1" << std::endl; } 
    UINT32 func2() { return 2; } 
}; 

void call_initialize (A *a) { 
    std::cout << a->initialize() << std::endl; 
} 

B b; 
C c; 
call_initialize(&b); 
call_initialize(&c); 

Результаты в выходе:

B::func1 
1 
C::func1 
2 

Это пример полиморфного поведения, потому что выход отличается в зависимости от того, если A был подклассы по B или путем C.

+0

Спасибо за ваше объяснение. Ваш пример действительно полезен !! .. Большое спасибо .. :) –

+0

@SitiHaslinaMohdZulkafli: Добро пожаловать. +1 на ваш вопрос. – jxh

0

Функции func1 & func2 не выполнены в A (согласно приведенному коду).
Если они реализованы, то они называются. Если есть производный класс для А и если объект для производного класса создается полиморфно, т.е.

class B : public A 
{ 
..... 
}; 

A* obj = new B(); 

obj->initialize(); 

Тогда func1() и func2() версии Б называются если В реализовали их.

Как упоминалось в комментарии Этана, вы не принимаете результат func2().
Так что вам нужно либо написать

UINT32 result = func2(); 

или

return func2(); 
+0

owh..you означает, что есть ошибка в этом коде?? .. Я просто понимаю. Да, может быть, это ошибка типографии. Я не так уверен, но ваша помощь очень ценится. Спасибо .. :) –

+0

Ни 'A :: func1', ни' A :: func2' не будут вызываться здесь, даже если они реализованы, поскольку они являются чисто виртуальными.Только производные классы, которые переопределяют их, могут быть созданы, и вместо этого будут вызываться эти переопределения. –

Смежные вопросы