Звиняй, не увидел, что это конструктор... Но, в конструкторе их надо ИНИЦИАЛИЗИРОВАТЬ (присваивать значения, в этом духе). А в описании класса их надо объявлять. Вот реальный тебе пример, сейчас над ним работаю.
Длинноват, но ничего.

typedef void (*typeSortFuncPointer)    (int* arr, const int size);
typedef void (*typeFillFuncPointer)    (int* arr, const int size, int n);

#include "JournalItem.h"
#include "LogItem.h"
class CBencher
{
protected:
    unsigned int        myNTries_;
    int            myLastPrecision_;
    unsigned long long int*    myAverageIterationsArray_;
    unsigned long long int*    myAverageSwapsArray_;
    unsigned int*        myMaxIterationsArray_;
    unsigned int*        myMaxSwapsArray_;
    unsigned int*        myMinIterationsArray_;
    unsigned int*        myMinSwapsArray_;
    unsigned int        mySwaps_;
    unsigned int        myIterations_;
    CJournalItem*        myJournal_;
    int            myCurrentJournalSize_;
    int            myMaxJournalSize_;
    CLogItem*        myLog_;
    int            myCurrentLogSize_;
    int            myMaxLogSize_;
    
    typeFillFuncPointer    myFillFunction_;
    typeSortFuncPointer    mySortFunction_;

    void eraseArrays (void);
public:
    CBencher (void);
    typeSortFuncPointer        setSortFunction     (typeSortFuncPointer p);
    typeFillFuncPointer        setFillFunction     (typeFillFuncPointer p);
    void                bench             (const int maxsize, const int numGradations, const int precision);
    const unsigned long long int*    getAverageSwaps        (void)                        const;
    const unsigned long long int*    getAverageIterations    (void)                        const;
    const unsigned int*        getMaxSwaps        (void)                        const;
    const unsigned int*        getMaxIterations    (void)                        const;
    const unsigned int*        getMinSwaps        (void)                        const;
    const unsigned int*        getMinIterations    (void)                        const;
    CJournalItem&            getJournalItem        (const unsigned int nTr)            const;
    CLogItem&            getLogItem        (const unsigned int nTr)            const;
    inline void            increaseSwaps ()    { mySwaps_++; }
    inline void            increaseIterations ()    { myIterations_++; }
    virtual                ~CBencher (void);
};
CBencher currentBencher;

#include "Strng.h"
#include "ArrFillers.h"

CBencher :: CBencher ()
{
    myMaxLogSize_ = myCurrentLogSize_ = myMaxJournalSize_ = myCurrentJournalSize_ = 0;
    myLog_                = new CLogItem [0];
    myJournal_            = new CJournalItem [0];
    myNTries_            = 0;
    myLastPrecision_        = 0;
    mySortFunction_            = CK :: optimizedBInsertSort;
    myFillFunction_            = randomFill;
    myAverageIterationsArray_    = NULL;
    myAverageSwapsArray_        = NULL;
    myMaxIterationsArray_        = NULL;
    myMaxSwapsArray_        = NULL;
    myMinIterationsArray_        = NULL;
    myMinSwapsArray_        = NULL;
    mySwaps_            = 0;
    myIterations_            = 0;
}

CBencher :: ~CBencher ()
{
    eraseArrays ();
}

inline void CBencher :: eraseArrays ()
{
    delete [] myAverageIterationsArray_;
    delete [] myAverageSwapsArray_;
    delete [] myMaxIterationsArray_;
    delete [] myMaxSwapsArray_;
    delete [] myMinIterationsArray_;
    delete [] myMinSwapsArray_;
}

inline typeFillFuncPointer CBencher :: setFillFunction (typeFillFuncPointer p)
{
    typeFillFuncPointer t = myFillFunction_;
    myFillFunction_ = p;
    return t;
}

inline typeSortFuncPointer CBencher :: setSortFunction (typeSortFuncPointer p)
{
    typeSortFuncPointer t = mySortFunction_;
    mySortFunction_ = p;
    return t;
}

void CBencher :: bench (const int maxsize, const int numGradations, const int precision)
{
    srand (static_cast<unsigned int>(time (NULL)));
    if (!numGradations) throw "CBencher::bench (): Second parameter is zero.";
    int mn = maxsize/numGradations;
    int* arrayForSadizm = new int [maxsize];

    eraseArrays ();

    myAverageIterationsArray_    = new unsigned long long int [numGradations];
    myAverageSwapsArray_        = new unsigned long long int [numGradations];
    myMaxIterationsArray_        = new unsigned int [numGradations];
    myMaxSwapsArray_        = new unsigned int [numGradations];
    myMinIterationsArray_        = new unsigned int [numGradations];
    myMinSwapsArray_        = new unsigned int [numGradations];
    
    myFillFunction_ (arrayForSadizm, maxsize, 0);

    for (int i = 0, currentSize = mn; i < numGradations; i++, currentSize += mn)
    {
        myMaxSwapsArray_ [i] = myMaxIterationsArray_ [i] = 0;
        myMinSwapsArray_ [i] = myMinIterationsArray_ [i] = 32500;
        myAverageIterationsArray_ [i] = myAverageSwapsArray_ [i] = 0;
        for (int j = 0; j <    precision; j++)
        {
            mySortFunction_ (arrayForSadizm, currentSize);
            cout << ".";
            myFillFunction_ (arrayForSadizm, maxsize, 0);
            cout << ".";
            myAverageIterationsArray_ [i]    += myIterations_;
            myAverageSwapsArray_ [i]    += mySwaps_;

            myMaxSwapsArray_ [i]        > mySwaps_    ? NULL : myMaxSwapsArray_ [i]        = mySwaps_;
            myMaxIterationsArray_ [i]    > myIterations_ ? NULL : myMaxIterationsArray_ [i] = myIterations_;

            myMinSwapsArray_ [i]        < mySwaps_    ? NULL : myMinSwapsArray_ [i]        = mySwaps_;
            myMinIterationsArray_ [i]    < myIterations_ ? NULL : myMinIterationsArray_ [i] = myIterations_;
            
            mySwaps_ = myIterations_ = 0;
        }
        myAverageIterationsArray_ [i]    /= precision;
        myAverageSwapsArray_ [i]    /= precision;
    }
    if (myMaxLogSize_ == myNTries_)
    {
        CLogItem* buf = new CLogItem [myCurrentLogSize_];
        for (int i = 0; i < myCurrentLogSize_; i++)
            buf [i] = myLog_ [i];
        delete [] myLog_;
        myMaxLogSize_ = myCurrentLogSize_ + myCurrentLogSize_;
        myLog_ = new CLogItem [myMaxLogSize_];
        for (int i = 0; i < myCurrentLogSize_; i++)
            myLog_ [i] = buf [i];
        delete [] buf;
    }
    CLogItem tObject (myAverageSwapsArray_,    myAverageIterationsArray_,
                      myMinSwapsArray_,        myMinIterationsArray_,
                      myMaxSwapsArray_,        myMaxIterationsArray_,
                      numGradations);
    myLog_ [myCurrentLogSize_++] = tObject;
    cout << endl;
    delete [] arrayForSadizm;
    myLastPrecision_ = precision;
    myNTries_++;
}

inline const unsigned long long int* CBencher :: getAverageSwaps () const
{
    if (!myAverageSwapsArray_) throw "CBencher::getAverageSwaps (): Return of null pointer. Possible error.";
    return myAverageSwapsArray_;
}

inline const unsigned long long int* CBencher :: getAverageIterations () const
{
    if (!myAverageIterationsArray_) throw "CBencher::getAverageIterations (): Return of null pointer. Possible error.";
    return myAverageIterationsArray_;
}

inline const unsigned int* CBencher :: getMaxSwaps (void) const
{
    if (!myMaxSwapsArray_) throw "CBencher::getMaxSwaps (): Return of null pointer. Possible error.";
    return myMaxSwapsArray_;
}

inline const unsigned int* CBencher :: getMaxIterations (void) const
{
    if (!myMaxIterationsArray_) throw "CBencher::getMaxIterations (): Return of null pointer. Possible error.";
    return myMaxIterationsArray_;
}

inline const unsigned int* CBencher :: getMinSwaps (void) const
{
    if (!myMinSwapsArray_) throw "CBencher::getMinSwaps (): Return of null pointer. Possible error.";
    return myMinSwapsArray_;
}

inline const unsigned int* CBencher :: getMinIterations (void) const
{
    if (!myMinIterationsArray_) throw "CBencher::getMinIterations (): Return of null pointer. Possible error.";
    return myMinIterationsArray_;
}

inline CJournalItem& CBencher :: getJournalItem (const unsigned int nTry) const
{
    if (nTry > myNTries_) throw "CBnecher::getJournalItem (): Index out of bounds.";
    static CJournalItem tObject = myJournal_ [nTry];
    return tObject;
}

inline CLogItem& CBencher :: getLogItem (const unsigned int nTry) const
{
    if (nTry > myNTries_) throw "CBencehr::getLogItem (): Index out of bounds.";
    static CLogItem tObject = myLog_ [nTry];
    return tObject;
}

Понял?