Объясните пожалуйста на примере написание абстрактного класса: допустим есть базовый класс А и производные В и С.
в базовом мы пишем virtual void abc()=0;
как все правильно записать в файле abc.h,abc.cpp,main.cpp

Цитата

как все правильно записать в файле abc.h,abc.cpp,main.cpp

Что правильно записать?Синтаксис?

пример программки, чтобы понятнее стало

Да обьясни ты толком,что тебе не понятно:что такое абстрактный класс?Как вызывать функции?

Код

//abc.h class A{ void abc()=0; }; class B : public A{  int abc(); }; class C : public A{  int abc(); }; //abc.cpp B::abc(){ //твой код } С::abc(){ //твой код }

не очень понятно как все это записать в каждом из файлов, хочется посмотреть как это все выглядит на примере

Ты хоть знаешь какое расширение и для чего служит? В h. описываешь класс. В АВС описываешь функции,а в МАIN твоя прога.Там и вываешь функции,обращаясь через указатель класса к функции,а компилятор сам определит,какую функцию вызвать(согласно таблице ,которую создает)

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

Ну держи

Код

//abc.h class A{ void abc()=0; }; class B : public A{ int abc(); }; class C : public A{ int abc(); }; //abc.cpp B::abc(){ //твой код } С::abc(){ //твой код }

теперь в MAIN-e

Код

A *LALA//создаешь указатель на обьект класса LALA=new B; LALA->abc();//вызывается метод класса B abc LALA=new C; LALA->abc();//вызывается метод класса C abc

Это сообщение отредактировал(а) Coocky - 1.4.2004, 22:46

Статьи из MSDN:

Virtual Functions

A virtual function is a member function that you expect to be redefined in derived classes. When you refer to a derived class object using a pointer or a reference to the base class, you can call a virtual function for that object and execute the derived class's version of the function.

Virtual functions ensure that the correct function is called for an object, regardless of the expression used to make the function call.

Suppose a base class contains a function declared as virtual and a derived class defines the same function. The function from the derived class is invoked for objects of the derived class, even if it is called using a pointer or reference to the base class. The following example shows a base class that provides an implementation of the PrintBalance function and two derived classes

// deriv_VirtualFunctions.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

class __declspec(dllexport) Account
{
public:
Account( double d ); // Constructor.
virtual double GetBalance(); // Obtain balance.
virtual void PrintBalance(); // Default implementation.
private:
double _balance;
};

// Implementation of constructor for Account.
Account::Account( double d )
{
_balance = d;
}

// Implementation of GetBalance for Account.
double Account::GetBalance()
{
return _balance;
}
// Default implementation of PrintBalance.
void Account::PrintBalance()
{
cerr << "Error. Balance not available for base type."
<< endl;
}

class __declspec(dllexport) CheckingAccount : public Account
{
public:
void PrintBalance();
};

// Implementation of PrintBalance for CheckingAccount.
void CheckingAccount::PrintBalance()
{
cout << "Checking account balance: " << GetBalance();
}

class __declspec(dllexport) SavingsAccount : public Account
{
public:
void PrintBalance();
};

// Implementation of PrintBalance for SavingsAccount.
void SavingsAccount::PrintBalance()
{
cout << "Savings account balance: " << GetBalance();
}

int main()
{
}
The PrintBalance function in the derived classes is virtual because it is declared as virtual in the base class, Account. To call virtual functions such as PrintBalance, code such as the following can be used:

// Create objects of type CheckingAccount and SavingsAccount.
CheckingAccount *pChecking = new CheckingAccount( 100.00 );
SavingsAccount *pSavings = new SavingsAccount( 1000.00 );

// Call PrintBalance using a pointer to Account.
Account *pAccount = pChecking;
pAccount->PrintBalance();

// Call PrintBalance using a pointer to Account.
pAccount = pSavings;
pAccount->PrintBalance();
In the preceding code, the calls to PrintBalance are identical, except for the object pAccount points to. Because PrintBalance is virtual, the version of the function defined for each object is called. The PrintBalance function in the derived classes CheckingAccount and SavingsAccount "override" the function in the base class Account.

If a class is declared that does not provide an overriding implementation of the PrintBalance function, the default implementation from the base class Account is used.

Functions in derived classes override virtual functions in base classes only if their type is the same. A function in a derived class cannot differ from a virtual function in a base class in its return type only; the argument list must differ as well.

When calling a function using pointers or references, the following rules apply:

A call to a virtual function is resolved according to the underlying type of object for which it is called.
A call to a nonvirtual function is resolved according to the type of the pointer or reference.
The following example shows how virtual and nonvirtual functions behave when called through pointers:

// deriv_VirtualFunctions2.cpp
// compile with: /EHsc

class __declspec(dllimport) Account
{
public:
Account( double d ); // Constructor.
virtual double GetBalance(); // Obtain balance.
virtual void PrintBalance(); // Default implementation.
private:
double _balance;
};

class __declspec(dllimport) CheckingAccount : public Account
{
public:
void PrintBalance();
};

class __declspec(dllimport) SavingsAccount : public Account
{
public:
void PrintBalance();
};


#include <iostream>

using namespace std;
// Declare a base class.
class Base
{
public:
virtual void NameOf(); // Virtual function.
void InvokingClass(); // Nonvirtual function.
};

// Implement the two functions.
void Base::NameOf()
{
cout << "Base::NameOf\n";
}

void Base::InvokingClass()
{
cout << "Invoked by Base\n";
}

// Declare a derived class.
class Derived : public Base
{
public:
void NameOf(); // Virtual function.
void InvokingClass(); // Nonvirtual function.
};

// Implement the two functions.
void Derived::NameOf()
{
cout << "Derived::NameOf\n";
}

void Derived::InvokingClass()
{
cout << "Invoked by Derived\n";
}

int main()
{
// Declare an object of type Derived.
Derived aDerived;
// Declare two pointers, one of type Derived * and the other
// of type Base *, and initialize them to point to aDerived.
Derived *pDerived = &aDerived;
Base *pBase = &aDerived;
// Call the functions.
pBase->NameOf(); // Call virtual function.
pBase->InvokingClass(); // Call nonvirtual function.
pDerived->NameOf(); // Call virtual function.
pDerived->InvokingClass(); // Call nonvirtual function.
}
Output
Derived::NameOf
Invoked by Base
Derived::NameOf
Invoked by Derived
Note that regardless of whether the NameOf function is invoked through a pointer to Base or a pointer to Derived, it calls the function for Derived. It calls the function for Derived because NameOf is a virtual function, and both pBase and pDerived point to an object of type Derived.

Because virtual functions are called only for objects of class types, you cannot declare global or static functions as virtual.

The virtual keyword can be used when declaring overriding functions in a derived class, but it is unnecessary; overrides of virtual functions are always virtual.

Virtual functions in a base class must be defined unless they are declared using the pure-specifier. (For more information about pure virtual functions, see Abstract Classes.)

The virtual function-call mechanism can be suppressed by explicitly qualifying the function name using the scope-resolution operator (:. Consider the earlier example involving the Account class. To call PrintBalance in the base class, use code such as the following:

CheckingAccount *pChecking = new CheckingAccount( 100.00 );

pChecking->Account::PrintBalance(); // Explicit qualification.

Account *pAccount = pChecking; // Call Account::PrintBalance

pAccount->Account::PrintBalance(); // Explicit qualification.
Both calls to PrintBalance in the preceding example suppress the virtual function-call mechanism.




Abstract Classes
Abstract classes act as expressions of general concepts from which more specific classes can be derived. You cannot create an object of an abstract class type; however, you can use pointers and references to abstract class types.

A class that contains at least one pure virtual function is considered an abstract class. Classes derived from the abstract class must implement the pure virtual function or they, too, are abstract classes.

A virtual function is declared as "pure" by using the pure-specifier syntax (described in Class Protocol Implementation). Consider the example presented in Virtual Functions. The intent of class Account is to provide general functionality, but objects of type Account are too general to be useful. Therefore, Account is a good candidate for an abstract class:

// deriv_AbstractClasses.cpp
class Account
{
public:
Account( double d ); // Constructor.
virtual double GetBalance(); // Obtain balance.
virtual void PrintBalance() = 0; // Pure virtual function.
private:
double _balance;
};

int main()
{
}
The only difference between this declaration and the previous one is that PrintBalance is declared with the pure specifier (= 0).

Royan ты че делаешь?Парень на бейсик перейдет Я ж ему обья снил и на словах и на примере ,а он улыбается