4. class is inaccessible

class is inaccessible

  • ?

    Hallo!
    Bitte helft mir! Was ist hier faul?

    alex@Buran:~/ASG/Asg21a> ./Makefile
    ../include/Chain.hh: In destructor ‘DynArrayChain::~DynArrayChain()’:
    ../include/Chain.hh:32: error: ‘class Link’ is inaccessible
    Buffer.cc:255: error: within this context
    ../include/Chain.hh:32: error: ‘class Link’ is inaccessible
    Buffer.cc:255: error: within this context
    ../include/Chain.hh:32: error: ‘class Link’ is inaccessible
    Buffer.cc:256: error: within this context
    ../include/Chain.hh:32: error: ‘class Link’ is inaccessible
    Buffer.cc:260: error: within this context

    Hier ist die Chain.hh
    // $Header
    /*---------- Global Header Descriptor Block ---------------------------------\
    |
    | class Link
    | class Chain
    |
    | #include "Chain.hh"
    |
    \    ---------------------------------------------------------------------------*/
    // $Log

    #ifndef _CHAIN_HH
    #define _CHAIN_HH

    #include <stdlib.h>
    //#include <bool.h>

    class Chain;

    /*-------- Internal Class Descriptor Block ----------------------------------\
    |
    | class Link
    | section of a chain, linked twice
    |
    \    ---------------------------------------------------------------------------*/

    class Link {

    friend class Chain;

    private:

    Link *plPrevious, *plNext;

    public:

    bool init (void);

    Link (void): plPrevious (NULL), plNext (NULL) { }
    ~Link (void) {init();};

    const Link *getPrevious (void) const {return plPrevious;}
    const Link *getNext (void) const {return plNext;}

    const Link *getFirst (void) const;
    const Link *getLast (void) const;

    const Link *getLinked (int) const;

    bool linked (void) const
    {if (plPrevious || plNext) return true; return false;}

    size_t getNumOfPreceding (void) const;
    size_t getNumOfFollowing (void) const;

    size_t getNum (void) const
    {return (1 + getNumOfPreceding() + getNumOfFollowing());}

    bool insert (Link &);
    bool insert (Link &, const int &);

    bool append (Link &);
    bool append (Link &, const int &);

    }; // --- end class Link

    /*-------- Internal Class Descriptor Block ----------------------------------\
    |
    | class Chain
    | dynamic list, with elements linked twice
    |
    \    ---------------------------------------------------------------------------*/

    class Chain: private Link {

    public:

    void init (void) {while (plNext) plNext->init();}

    Chain (void): Link () {}
    ~Chain (void) {init();}

    const Link *getFirst (void) const {return plNext;}
    const Link *getLast (void) const
    {return (plNext? plNext->getLast(): (Link 😉 NULL);}

    const Link *operator[] (const size_t &i) const {return getLinked (i + 1);}

    size_t getNumber (void) const {return getNumOfFollowing();}

    bool insert (Link &l)
    {return (plNext? plNext->insert (l): Link::append (l));}

    bool append (Link &l)
    {return (plNext? ((Link 😉 getLast())->append (l): Link::append (l));}

    bool insert (Chain &);
    bool append (Chain &);

    }; // --- end class Chain

    #endif // def _LINK_HH

    Hier ist die Buffer.cc
    #include <stdlib.h>
    #include <Buffer.hh>

    /*-------- Internal Class Descriptor Block ----------------------------------\
    |
    | class DynArraySegment
    | data-section for dynamic array
    |
    \    ---------------------------------------------------------------------------*/

    class DynArraySegment: protected Link
    {

    friend void *DynArrayChain::operator[] (const size_t &) const;
    friend bool DynArrayChain::contains (const size_t &i) const;

    protected:

    size_t iArray, iData;
    void *aData;

    size_t iFirst;

    public:

    DynArraySegment (const size_t &iA, const size_t &iD, size_t iF = 0):
    iArray (iA), iData (iD), iFirst (iF), aData (NULL)
    {
    if (iA) aData = calloc (iA, iD);
    }

    ~DynArraySegment (void) {if (iArray) free (aData);}

    const size_t &getSegmentSize (void) const {return iArray;}
    const size_t &getDataSize (void) const {return iData;}

    const size_t &getLoLabel (void) const {return iFirst;}
    size_t getHiLabel (void) const {return (iFirst + iArray - 1);}

    void *operator[] (const size_t &i);

    bool shift (const size_t &);
    }; // --- end class DynArraySegment

    // === functions for class DynArraySegment

    /*-------- Internal Function Descriptor Block -------------------------------\
    |
    | get i'th entry of array section
    |
    | Access:
    | void DynArraySegment::operator[] (const size_t &i);
    |
    | Return Code:
    | void pointer, NULL in case of error
    |
    \    ---------------------------------------------------------------------------    /

    void *DynArraySegment::operator[] (const size_t &i)
    {
    // --- init

    if (i < iFirst)
    { // --- there should be really no way to come here
    cout << "\n%% ERROR: request for data out of array\n";
    return NULL;
    } // --- end if

    size_t iLocal = (i - iFirst);

    // --- get from this section

    if (iLocal < iArray)
    {
    size_t iStep = (iLocal * iData);
    size_t iRet = ((size_t) aData) + iStep;
    void *pRet = (void 😉 iRet;

    return pRet;
    } // --- end if

    // --- switch to next section, create if necessary

    DynArraySegment *pd = (DynArraySegment 😉 getNext();

    if (!pd)
    {
    size_t iNewFirst = (((size_t) (i / iArray)) * iArray);

    pd = new DynArraySegment (iArray, iData, iNewFirst);
    if (!pd)
    {
    cout << "\n%%FATAL: alloc failed! exiting...\n";
    exit(1);
    }

    if (!append (*pd))
    {
    cout << "\n%% ERROR: enlarging dynamic array failed\n";
    return NULL;
    } // --- end if

    }
    else if (i < pd->iFirst)
    {
    size_t iNewFirst = (((size_t) (i / iArray)) * iArray);

    size_t iNewArray = (pd->iFirst - iNewFirst);
    if (iNewArray > iArray)
    iNewArray = iArray;

    pd = new DynArraySegment (iNewArray, iData, iNewFirst);
    if (!pd)
    {
    cout << "\n%%FATAL: alloc failed! exiting...\n";
    exit(1);
    }

    if (!append (*pd))
    {
    cout << "\n%% ERROR: enlarging dynamic array failed\n";
    return NULL;
    } // --- end if
    } // --- end if else

    return pd->operator[] (i);

    } // --- end void *DynArraySegment::operator[]

    /*-------- Internal Function Descriptor Block -------------------------------\
    |
    | shift dynamic array
    |
    | Access:
    | bool DynArraySegment::shift (const size_t &);
    |
    | Return Code:
    | bool
    |
    \    ---------------------------------------------------------------------------*/

    bool DynArraySegment::shift (const size_t &iShift)
    {

    iFirst += iShift;

    Link *pl = (Link 😉 getNext();
    if (pl)
    return ((DynArraySegment 😉 pl)->shift (iShift);

    return true;
    } // --- end bool DynArraySegment::shift (const size_t &);

    // === functions for class DynArrayChain

    /*-------- Internal Function Descriptor Block -------------------------------\
    |
    | init dynamic array
    |
    | Access:
    | DynArrayChain::DynArrayChain (const size_t &iA, const size_t &iD);
    |
    | Return Code:
    | none
    |
    \    ---------------------------------------------------------------------------*/

    DynArrayChain::DynArrayChain (const size_t &iA, const size_t &iD):
    iArray (iA), iData (iD)
    {

    if (!iD)
    {
    cout << "\n%% ERROR: creating dynamic array for data size 0'\\n"; iArray = 0; } else if (!iA) { cout << "\\n%% WARNING: attempt to create dynamic array with size0'\n"
    << "%% setting to default = " << MAX_ENT_ARRAY << endl;

    iArray = MAX_ENT_ARRAY;
    } // --- end if else
    } // --- end DynArrayChain::DynArrayChain

    /*-------- Internal Function Descriptor Block -------------------------------\
    |
    | destruct dynamic array
    |
    | Access:
    | DynArrayChain::~DynArrayChain (void);
    |
    | Return Code:
    | none
    |
    \    ---------------------------------------------------------------------------*/

    DynArrayChain::~DynArrayChain (void)
    {
    Link
    *pl = (Link 😉 getFirst(),
    *plNext;

    while (pl)
    {
    plNext = (Link 😉 pl->getNext();
    if (pl)
    delete ((DynArraySegment 😉 pl);

    pl = plNext;
    } // --- end while
    } // --- end DynArrayChain::~DynArrayChain

    /*-------- Internal Function Descriptor Block -------------------------------\
    |
    | get label info
    |
    | Access:
    | size_t DynArrayChain::getLoLabel (void) const;
    | size_t DynArrayChain::getHiLabel (void) const;
    |
    | Return Code:
    | size_t
    |
    \    ---------------------------------------------------------------------------*/

    size_t DynArrayChain::getLoLabel (void) const
    {
    const DynArraySegment *pd = (DynArraySegment 😉 getFirst();

    if (!pd)
    return 0;

    return pd->getLoLabel();
    } // --- end size_t DynArrayChain::getLoLabel

    size_t DynArrayChain::getHiLabel (void) const
    {
    const DynArraySegment *pd = (DynArraySegment 😉 getLast();

    if (!pd)
    return 0;

    return pd->getHiLabel();
    } // --- end size_t DynArrayChain::getHiLabel

    /*-------- Internal Function Descriptor Block -------------------------------\
    |
    | query position
    |
    | Access:
    | bool DynArrayChain::contains (const size_t &i) const;
    |
    | Return Code:
    | bool
    |
    \    ---------------------------------------------------------------------------*/

    bool DynArrayChain::contains (const size_t &i) const
    {
    const DynArraySegment *pd = (DynArraySegment 😉 getFirst();

    size_t iLo, iHi;

    while (pd)
    {
    iLo = pd->getLoLabel();
    iHi = pd->getHiLabel();

    if ((i >= iLo) && (i <= iHi))
    return true;

    pd = (DynArraySegment 😉 pd->getNext();

    } // --- end while

    return false;
    } // --- end bool DynArrayChain::contains

    /*-------- Internal Function Descriptor Block -------------------------------\
    |
    | get i'th entry of dynamic array
    | CAVE: not modifying entries (pretending const'ness)
    | but dynamically extending array on request
    |
    | Access:
    | void DynArrayChain::operator[] (const size_t &i) const;
    |
    | Return Code:
    | void pointer, NULL in case of error
    |
    \    ---------------------------------------------------------------------------    /

    void *DynArrayChain::operator[] (const size_t &i) const
    {
    DynArraySegment *pd = (DynArraySegment 😉 getFirst();

    if (!pd)
    {
    if (!iData)
    {
    cout << "\n%% ERROR: request for data with size `0'\n";
    return NULL;
    } // --- end if

    size_t iNewFirst = (((size_t) (i / iArray)) * iArray);

    pd = new DynArraySegment (iArray, iData, iNewFirst);
    if (!pd)
    {
    cout << "\n%%FATAL: alloc failed! exiting...\n";
    exit(1);
    }

    // CAVE: overwriting const'ness by casting `this' to (DynArrayChain 😉
    if (!((DynArrayChain 😉 this)->insert (*pd))
    {
    cout << "\n%% ERROR: enlarging dynamic array failed\n";
    return NULL;
    } // --- end if
    }
    else if (i < pd->iFirst)
    {
    size_t iNewFirst = (((size_t) (i / iArray)) * iArray);

    size_t iNewArray = (pd->iFirst - iNewFirst);
    if (iNewArray > iArray)
    iNewArray = iArray;

    pd = new DynArraySegment (iNewArray, iData, iNewFirst);
    if (!pd)
    {
    cout << "\n%%FATAL: alloc failed! exiting...\n";
    exit(1);
    }

    // CAVE: overwriting const'ness by casting `this' to (DynArrayChain 😉
    if (!((DynArrayChain 😉 this)->insert (*pd))
    {
    cout << "\n%% ERROR: enlarging dynamic array failed\n";
    return NULL;
    } // --- end if
    } // --- end if else

    return pd->operator[] (i);
    } // --- end void *DynArrayChain::operator[]

    /*-------- Internal Function Descriptor Block -------------------------------\
    |
    | shift array
    |
    | Access:
    | bool DynArrayChain::shift (const size_t &);
    |
    | Return Code:
    | bool
    |
    \    ---------------------------------------------------------------------------*/

    bool DynArrayChain::shift (const size_t &iShift)
    {
    Link *pl = (Link 😉 getFirst();

    return (pl? ((DynArraySegment 😉 pl)->shift (iShift): true);
    } // --- end bool DynArrayChain::shift

    // === class DynBufferData

    /*-------- Internal Class Descriptor Block ----------------------------------\
    |
    | class DynBufferData
    | data-section for buffer
    |
    \    ---------------------------------------------------------------------------*/

    class DynBufferData: private DynArraySegment
    {
    friend void *DynBufferChain::get (void);

    bool *abUsed, bUsed;
    size_t iUsed, iMaxUsed;

    public:

    DynBufferData::DynBufferData (const size_t &iArray, const size_t &iData);
    ~DynBufferData (void) {if (DynArraySegment::iArray) delete[] abUsed;}

    DynArraySegment::getSegmentSize;
    DynArraySegment::getDataSize;
    const size_t &getUsed (void) const {return iUsed;}
    const size_t &getMaxUsed (void) const {return iMaxUsed;}

    void *get (void);
    bool release (const void *);

    }; // --- end class DynBufferData

    // === functions for class DynBufferData

    /*-------- Internal Function Descriptor Block -------------------------------\
    |
    | construct section of dynamic buffer
    |
    | Access:
    | DynBufferData::DynBufferData (const size_t &iA, const size_t &iD);
    |
    | Return Code:
    | none
    |
    \    ---------------------------------------------------------------------------*/

    DynBufferData::DynBufferData (const size_t &iA, const size_t &iD):
    DynArraySegment (iA, iD),
    abUsed (NULL), bUsed (true),
    iUsed (0), iMaxUsed (0)
    {

    if (iA)
    {
    abUsed = new bool [iA];
    if (!abUsed)
    {
    cout << "\n%%FATAL: alloc failed! exiting...\n";
    exit(1);
    }
    bUsed = false;
    for (int i = 0; i < iA; i++)
    abUsed [i] = false;
    } // --- end if
    } // --- end DynBufferData::DynBufferData

    /*-------- Internal Function Descriptor Block -------------------------------\
    |
    | get entry of dynamic buffer
    |
    | Access:
    | void DynBufferData::get (void);
    |
    | Return Code:
    | void pointer
    |
    \    ---------------------------------------------------------------------------    /

    void *DynBufferData::get (void)
    {
    if (!bUsed)
    {
    for (int i = 0; i < iArray; i++)
    {
    if (!(abUsed [i]))
    {
    abUsed [i] = true;
    iUsed++;

    if (iUsed > iMaxUsed)
    iMaxUsed = iUsed;
    if (iUsed == iArray)
    bUsed = true;

    return operator[] (i);
    } // --- end if
    } // --- end for
    // --- routine should NEVER reach this point!
    cout << "\n%% WARNING: corrupt buffer\n";
    } // --- end if

    DynBufferData *pd = (DynBufferData 😉 getNext();

    if (!pd)
    {
    pd = new DynBufferData (iArray, iData);
    if (!pd)
    {
    cout << "\n%%FATAL: alloc failed! exiting...\n";
    exit(1);
    }

    if (!append (*pd))
    {
    cout << "\n%% ERROR: enlarging dynamic buffer failed\n";
    return NULL;
    } // --- end if
    } // --- end if

    return pd->get();

    } // --- end void *DynBufferData::get

    /*-------- Internal Function Descriptor Block -------------------------------\
    |
    | release entry of dynamic buffer
    |
    | Access:
    | bool DynBufferData::release (const void pData);
    |
    | Return Code:
    | bool instance
    |
    \    ---------------------------------------------------------------------------    /

    bool DynBufferData::release (const void *pData)
    {
    int iInc = (((int) pData) - ((int) aData));

    double dPos = (((double) iInc) / ((double) iData));
    int iPos = (int) dPos;

    // --- correcting inaccurate division
    if ((dPos != (double) iPos) && ((dPos - iPos) < -.5))
    iPos++;

    if (iPos >= iArray)
    { // not in this buffer

    Link *pl = ((Link 😉 getNext());
    if (!pl)
    {
    cout << "\n%% WARNING: request to release out of array!\n";
    return false;
    } // --- end if
    return ((DynBufferData 😉 pl)->release (pData);
    } // --- end if

    if (!(abUsed [iPos]))
    {
    cout << "\n%% WARNING: attempt to release unused entry!\n";
    return false;
    } // --- end if

    abUsed [iPos] = false;
    iUsed--;

    bUsed = false;
    return true;
    } // --- end bool DynBufferData::release

    // === functions for class DynBufferChain

    /*-------- Internal Function Descriptor Block -------------------------------\
    |
    | init dynamic array
    |
    | Access:
    | DynBufferChain::DynBufferChain (const size_t &iA, const size_t &iD);
    |
    | Return Code:
    | none
    |
    \    ---------------------------------------------------------------------------*/

    DynBufferChain::DynBufferChain (const size_t &iA, const size_t &iD):
    iArray (iA), iData (iD)
    {
    if (!iD)
    {
    cout << "\n%% ERROR: attempt to create dynamic array for data size 0'\\n"; iArray = 0; } else if (!iA) { cout << "\\n%% WARNING: attempt to create dynamic array with size0'\n"
    << "%% setting to default = " << MAX_ENT_ARRAY << endl;
    iArray = MAX_ENT_ARRAY;
    } // --- end if else
    } // --- end DynBufferChain::DynBufferChain

    /*-------- Internal Function Descriptor Block -------------------------------\
    |
    | destruct dynamic buffer
    |
    | Access:
    | DynBufferChain::~DynBufferChain (void);
    |
    | Return Code:
    | none
    |
    \    ---------------------------------------------------------------------------*/

    DynBufferChain::~DynBufferChain (void)
    {
    Link *pl = (Link 😉 getFirst();
    DynBufferData *pd;

    size_t
    iArraySize = 0,
    iSegments = 0,
    iMaxUsed = 0;

    while (pl)
    {
    pd = (DynBufferData 😉 pl;
    iArraySize += pd->getSegmentSize();
    iSegments++;
    iMaxUsed += pd->getMaxUsed();

    pl = (Link 😉 pl->getNext();

    delete pd;

    } // --- end while

    #ifdef DEBUG
    if (iMaxUsed)
    cout
    << "used " << iMaxUsed
    << " of " << iArraySize
    << " in " << iSegments << " segments\n";
    else
    cout << "unused\n";
    #endif /* DEBUG */

    } // --- end DynBufferChain::~DynBufferChain

    /*-------- Internal Function Descriptor Block -------------------------------\
    |
    | get number of currently/maximum used entries
    |
    | Access:
    | size_t DynBufferChain::getUsed (void) const;
    | size_t DynBufferChain::getMaxUsed (void) const;
    |
    | Return Code:
    | size_t
    |
    \    ---------------------------------------------------------------------------*/

    size_t DynBufferChain::getUsed (void) const
    {
    size_t iRet = 0;

    const DynBufferData *pd = (const DynBufferData 😉 getFirst();

    while (pd)
    {
    iRet += pd->getUsed();

    pd = (const DynBufferData 😉 ((const Link 😉 pd)->getNext();
    } // --- end while

    return iRet;
    } // --- end size_t DynBufferChain::getUsed

    size_t DynBufferChain::getMaxUsed (void) const
    {

    size_t iRet = 0;

    const DynBufferData *pd = (const DynBufferData 😉 getFirst();

    while (pd)
    {
    iRet += pd->getMaxUsed();
    pd = (const DynBufferData 😉 ((const Link 😉 pd)->getNext();
    } // --- end while

    return iRet;
    } // --- end size_t DynBufferChain::getMaxUsed

    /*-------- Internal Function Descriptor Block -------------------------------\
    |
    | get entry of dynamic buffer
    |
    | Access:
    | void DynBufferChain::get (void);
    |
    | Return Code:
    | void pointer, NULL in case of error
    |
    \    ---------------------------------------------------------------------------    /

    void *DynBufferChain::get (void)
    {
    DynBufferData *pd = (DynBufferData 😉 getFirst();

    if (!pd)
    {
    if (!iData)
    {
    cout << "\n%% ERROR: request for data with size `0'\n";
    return NULL;
    } // --- end if

    pd = new DynBufferData (iArray, iData);
    if (!pd)
    {
    cout << "\n%%FATAL: alloc failed! exiting...\n";
    exit(1);
    }

    if (!insert (*pd))
    {
    cout << "\n%% ERROR: enlarging dynamic buffer failed\n";
    return NULL;
    } // --- end if
    } // --- end if

    return pd->get();
    } // --- end void *DynBufferChain::get

    /*-------- Internal Function Descriptor Block -------------------------------\
    |
    | release entry of dynamic buffer
    |
    | Access:
    | bool DynBufferChain::release (const void );
    |
    | Return Code:
    | bool instance
    |
    \    ---------------------------------------------------------------------------    /

    bool DynBufferChain::release (const void *p)
    {
    Link *pl = (Link 😉 getFirst();

    if (!pl)
    {
    cout << "\n%% WARNING: request to release out of array!\n";
    return false;
    } // --- end if

    return ((DynBufferData 😉 pl)->release (p);
    } // --- end bool DynBufferChain::release

    /* EOF */

    0
  • C

    Erstens: sfds

    Zweitens: Könntest du den Text bitte ein wenig zusammenstutzen? Niemand hat Lust, sich durch fast 900 Zeilen Code auf der Suche nach möglichen Fehlern durchzuwühlen.

    0
Anmelden zum Antworten