Nested class and constructor calling understanding

Question

I'm currently having an assignment, in which i need to create a DATABASE class,
which contains a employees pointers array, and private inner class,
that defines employees linked list

the goal to accomplish here, according to the assignment, is working acording
to a DB_TYPE defined constant.

when DB_TYPE = 0 i need my class methods to work with the employees pointers array,
when DB_TYPE = 1 i need my class methods to work with the employees linked list.

Therefore, i need two things:
1. Understanding constructor calling -
When i construct a new DATABASE object, for example with no paramaters,
the default constructor is called.
How do i call the linked list inner constructor to construct a Node, from the constructor itself?

2. Working according to the DB_TYPE constant -
I Suppose that's less of a trouble, as i can set my methods to work with
two cases\or with 'if' conditions regarding each value of DB_TYPE.
but if that's not that simple, i'll be glad to get some advise\help on how to do so.

EDIT: My Current code:

    class DataBase {
    public:
    DataBase();

    private:
        Employee ** empArr; /*!< Employees pointers array */
        unsigned int empCount;
        Node head;

    class Node{
    public:
        Node();  
        Node(Employee * emp, Node * next);

    private:
        Employee * emp; /*!< Employee Pointer */
        Node * next; /*!< The next node (containing the next employee) */

    };
    };

Thanks,
Adiel

The other way around - Node is nested inside DATABASE. About the nested Node being private - that's the assignment instructions, not mine :) — Adiel, May 24 '14 at 12:23
You can only call constructors on objects. If you have class `A` with nested class `A::B`, then creating an `A` doesn't create a `B` also. Class `B` is just like any other class , except that its name is scoped to `A::`. If you want an object of type `A::B` you need to declare one (e.g. `B b;` within `A`'s definition). Then you invoke its constructor the same way you invoke any member's constructor (i.e. via the constructor initialization list). — M.M, May 24 '14 at 12:24
@MattMcNabb Thanks, but when i try to create a private B member in A declaration ( B b; ), i get the following error : `‘B’ does not name a type` About DB_TYPE, it is a pre-processor. Thanks — Adiel, May 24 '14 at 12:40
@MattMcNabb i've edited my question posting the code. The error is upon **Node head;** member - `Node does not name a type` — Adiel, May 24 '14 at 12:52

score 0 · Answer 1 · answered May 24 '14 at 13:09

The Node node; has to come after the definition of class Node.

To invoke a non-default constructor of node when creating a Database you use the constructor initialization list:

Database::Database()
    : head(foo, bar)
    , empCount(0)
    , empArr(nullptr)
{
}

You can and should initialize the other members in this list too. If the object needs complicated initialization you can write a function to do that; initializing via the constructor body should be a last resort. (well, a later resort, it's not a terrible thing).

Note that the order member objects are initialized is the order they appear in the class definition - not the order they appear in the constructor init list. So if, for example, your head's constructor argument had to be worked out from empArr, you would have to make sure that Node head; came after Employee **empArr;, and also you'd have to write a function to set up empArr so your list would look like

: empCount(5), empArr( allocate_emparr(5) ), head(empArr[0], nullptr)

Re. DB_TYPE. Since it is preprocessor you can do, wherever appropriate,

#if DB_TYPE
    // code for processing linked list
#else
    // code for processing pointers array
#endif

This is very powerful, although some people consider it ugly. It's be nicer to use a template instead, especially if the class definition can stay the same and it is only a small number of functions whose behaviour needs to change. However it is challenging to write the template version well if you have not used templates much before.

Example declarations (could be class members or free functions):

template<int N> void do_something(void);

template<> void do_something<0>(void) { /* process pointers array */ }
template<> void do_something<1>(void) { /* process linked list */ }

Usage:

void other_func(void)
{
    do_something<DB_TYPE>();
}

Nested class and constructor calling understanding

1 Answers1

Linked