Вообщем таки дела. Я в классах ни бум бум имею только общее представление.
Тема такая, мы работаем в BCW, проходим массивы (класс Array, AbstractArray и другие)
Вообщем в классе AbstractArray есть такая процедура removeEntry которая protected. Так вот, препод сказала использовать именно ее и никакую другую. Причем как я понял надо создать свой класс в него как бы ключить класс AbstractArray и сделать эту функцию public. Помогите плиз, я итак вертел и эдак, чето кучу ошибок выдает. Заранее спасибо. (При возможности прокоментируйте плиз)

наследуешь свой класс от AbstractArray, потом в нем когда и где тебе нужно вызываешь функцию removeEntry
Добавлено @ 00:32
Быть может, эта тема поможет: Удаление выделенной строки в StringGrid, там реализуется нечто подобное.

если хочешь вызывать из внешей ф-ии removeEntry через свой класс наследуешь AbstractArray как public

Да это я понял, мне конкретно надо. Плиз, это же не много!


------------------------------------------------------------------------------------------------------------------------------
Вообщем как я понял, надо делать так

void main()
{
class NewClass: public AbstractArray
{};

Array A(5);
NewClass B(5); <-------(2 Errors)
..........................
..........................
};

Он выдает ошибки на помеченной строке:
1. Cannot create instance of abstract class 'NewClass'
2. Compilier couldn't generate default constructor for class 'NewClass'
-------------------------------------------------------------------------------------------------------------------------------

пробовал менять AbstractArray на Array (он является надмножеством для AbstractArray). 1-й Error пропал, 2-й остался такой же

Это сообщение отредактировал(а) bobaddd - 28.3.2006, 19:59

Судя по ошибке:

...и тому, как ты наследуешь свой класс от AbstractArray:

...класс AbstractArray является абстрактным, а в классе-потомке NewClass ты не переопределяешь ни одной функции. Посмотри, какие функции в AbstractArray объявлены чисто виртуальными, что там не определено, и сделай это в своем классе.

тоесть мне надо переопределить removeEntry и сделать ее паблик?

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

Это сообщение отредактировал(а) bobaddd - 28.3.2006, 22:56

bobaddd, есть код реализации класса AbstractArray? Если есть, кинь сюда. BCW стоит не у многих...

Файл Array.h Который подключает класс AbstractArray

/*------------------------------------------------------------------------*/
/* */
/* ARRAY.H */
/* */
/* Copyright Borland International 1991, 1992 */
/* All Rights Reserved */
/* */
/*------------------------------------------------------------------------*/

#if !defined( __ARRAY_H )
#define __ARRAY_H

#if defined( TEMPLATES )

#if !defined( __ARRAYS_H )
#include <Arrays.h>
#endif // __ARRAYS_H

#pragma option -Vo-
#if defined( __BCOPT__ ) && !defined( _ALLOW_po )
#pragma option -po-
#endif

#define Array BI_TCArrayAsVector
#define PArray PBI_TCArrayAsVector
#define RArray RBI_TCArrayAsVector
#define RPArray RPBI_TCArrayAsVector
#define PCArray PCBI_TCArrayAsVector
#define RCArray RCBI_TCArrayAsVector

_CLASSDEF( BI_TCArrayAsVector )

#define ArrayIterator BI_TCArrayAsVectorIterator
#define PArrayIterator PBI_TCArrayAsVectorIterator
#define RArrayIterator RBI_TCArrayAsVectorIterator
#define RPArrayIterator RPBI_TCArrayAsVectorIterator
#define PCArrayIterator PCBI_TCArrayAsVectorIterator
#define RCArrayIterator RCBI_TCArrayAsVectorIterator

_CLASSDEF( BI_TCArrayAsVectorIterator )

#else // TEMPLATES

#if !defined( __CLSTYPES_H )
#include <ClsTypes.h>
#endif // __CLSTYPES_H

#if !defined( __OBJECT_H )
#include <Object.h>
#endif // __OBJECT_H

#if !defined( __ABSTARRY_H )
#include <AbstArry.h>
#endif // __ABSTARRY_H

#pragma option -Vo-
#if defined( __BCOPT__ ) && !defined( _ALLOW_po )
#pragma option -po-
#endif

_CLASSDEF(Array)

class _CLASSTYPE Array : public AbstractArray

{

public:

Array( int upper, int lower = 0, sizeType aDelta = 0 ) :
AbstractArray( upper, lower, aDelta )
{
}

virtual void add( Object _FAR & );
void addAt( Object _FAR &, int );

virtual classType isA() const
{
return arrayClass;
}

virtual char _FAR *nameOf() const
{
return "Array";
}

};

#endif // TEMPLATES

#if defined( __BCOPT__ ) && !defined( _ALLOW_po )
#pragma option -po.
#endif
#pragma option -Vo.

#endif // __ARRAY_H

А вот файл AbstArry.h

/*------------------------------------------------------------------------*/
/* */
/* ABSTARRY.H */
/* */
/* Copyright Borland International 1991, 1992 */
/* All Rights Reserved */
/* */
/*------------------------------------------------------------------------*/

#if !defined( __ABSTARRY_H )
#define __ABSTARRY_H

#if defined( TEMPLATES )

#if !defined( __COLLECT_H )
#include <Collect.h>
#endif // __COLLECT_H

#if !defined( __MEM_H )
#include <Mem.h>
#endif // __MEM_H

#pragma option -Vo-
#if defined( __BCOPT__ ) && !defined( _ALLOW_po )
#pragma option -po-
#endif

_CLASSDEF(ostream)
_CLASSDEF(ContainerIterator)
_CLASSDEF(AbstractArray)
_CLASSDEF(ArrayIterator)

class _CLASSTYPE AbstractArray: public Collection
{

public:

friend class ArrayIterator;

virtual Object _FAR & operator []( int loc ) = 0;

virtual int lowerBound() const = 0;
virtual int upperBound() const = 0;
virtual sizeType arraySize() const = 0;

virtual void detach( int loc, DeleteType dt = NoDelete ) = 0;
virtual void detach( Object _FAR &, DeleteType dt = NoDelete ) = 0;
void destroy( int i )
{
detach( i, Delete );
}

int isEqual( const Object _FAR & ) const;
void printContentsOn( ostream _FAR & ) const;

};

#else // TEMPLATES

#if !defined( __COLLECT_H )
#include <Collect.h>
#endif // __COLLECT_H

#if !defined( __MEM_H )
#include <Mem.h>
#endif // __MEM_H

#if !defined( __CHECKS_H )
#include <Checks.h>
#endif // __CHECKS_H

#pragma option -Vo-
#if defined( __BCOPT__ ) && !defined( _ALLOW_po )
#pragma option -po-
#endif

_CLASSDEF(ostream)
_CLASSDEF(ContainerIterator)
_CLASSDEF(AbstractArray)
_CLASSDEF(ArrayIterator)

class _CLASSTYPE AbstractArray: public Collection
{

public:

AbstractArray( int, int = 0, sizeType = 0 );
virtual ~AbstractArray();

Object _FAR & operator []( int ) const;

int lowerBound() const
{
return lowerbound;
}

int upperBound() const
{
return upperbound;
}

sizeType arraySize() const;

virtual void detach( Object _FAR &, DeleteType = NoDelete );
virtual void detach( int, DeleteType = NoDelete );
void destroy( int i ) { detach( i, DefDelete ); }
virtual void flush( DeleteType = DefDelete );

virtual int isEqual( const Object _FAR & ) const;
virtual void printContentsOn( ostream _FAR & ) const;

virtual ContainerIterator _FAR & initIterator() const;

protected:

Object _FAR & objectAt( int i ) const
{
return *theArray[ zeroBase(i) ];
}

Object _FAR *ptrAt( int i ) const
{
return theArray[ zeroBase(i) ];
}

int find( const Object _FAR & );

void reallocate( sizeType );

void setData( int, Object _FAR * );

void insertEntry( int );
void removeEntry( int );
void squeezeEntry( int );

sizeType delta;
int lowerbound;
int upperbound;
int lastElementIndex;

private:

Object _FAR * _FAR *theArray;

int zeroBase( int loc ) const
{
PRECONDITION( loc >= lowerbound && loc <= upperbound );
return loc - lowerbound;
}

int boundBase( unsigned loc ) const
{
PRECONDITION( loc == UINT_MAX || loc <= upperbound - lowerbound );
return loc == UINT_MAX ? INT_MAX : loc + lowerbound;
}

friend class ArrayIterator;

};

inline Object _FAR & AbstractArray::operator [] ( int atIndex ) const
{
return objectAt( atIndex );
}

inline sizeType AbstractArray::arraySize() const
{
return sizeType( upperbound - lowerbound + 1 );
}

class _CLASSTYPE ArrayIterator : public ContainerIterator
{

public:

ArrayIterator( const AbstractArray _FAR & );
virtual ~ArrayIterator();

virtual operator int();
virtual Object _FAR & current();
virtual Object _FAR & operator ++( int );
virtual Object _FAR & operator ++();
virtual void restart();

private:

int currentIndex;
const AbstractArray _FAR & beingIterated;

void scan();

};

#endif // TEMPLATES

#if defined( __BCOPT__ ) && !defined( _ALLOW_po )
#pragma option -po.
#endif
#pragma option -Vo.

#endif // __ABSTARRY_H

1.Класс создавать внутри main можно но как бы не принято.
2.Класс - это тип данных. Требуется еще и переменная, называемая обьектом или экземпляром класса.
3.Все методы(функции), записанные как =0 называются чисто виртуальными, класс, содержащий такие методы - абстрактным. Нельзя создать экземпляр абстрактного класса. Для создания неабстрактного класса - наследника нужно создать самому все абстрактные методы.
4.Для получения доступа к защищенному методу из класса-наследника создают в нем публичный метод