Hidden Implementation

    I want to create one simple interface. One class has one private
data member and more than 10 public member functions. It does not
have private member functions.
    The client includes a header. He only needs to see simple interface,
but he does not know hidden implantation. He uses class A to invoke
doit() function and/or other public member functions.
    doit() function may have small or big algorithm, but client does not
know what algorithm is doing.
    I need to create another class or global function. Another class or
global function is defined in source code. The global function like
doSomething_1(=85) and doSomething_2(=85) may have more than 8
parameters. It is located inside doit() function.

// Interface.h
class A {
public:
    A();
    ~A();

    int getValue();
    void setValue( int value );

    void doit();

private:
    int m_data;
};

// interface.cpp
void doSomething_1( int &a, int &b, int &c, int &d, int &e, int &f,
int &g, int &h );

void doSomething_2( int &a, int &b, int &c, int &d, int &e, int &f,
int &g, int &h );

void doSomething_1( int &a, int &b, int &c, int &d, int &e, int &f,
int &g, int &h ) {
    // do something=85
    doSomething_2( a, b, c, d, e, f, g, h );
}

void doSomething_2( int &a, int &b, int &c, int &d, int &e, int &f,
int &g, int &h ) {
    // do something=85
}

A::A() : m_data( 0 ) {
}

A::~A() {
}

int A::getValue() {
    return m_data;
}

void A::setValue( int value ) {
    if ( value > 10 )
        value = 10;

    else if ( value < 0 )
        value = 0;

    m_data = value;
}

void A::doit() {
    int a = 0;
    int b = 1;
    int c = 2;
    int d = 3;
    int e = 4;
    int f = 5;
    int g = 6;
    int h = 7;

    doSomething_1( a, b, c, d, e, f ,g, h );

    // after 8 local variables are complete, it modifies the final value
back to private data member =96 m_data
}

int main() {
    A a;
    a.doit();

    return 0;
}

    doit() has 8 local variables. It invokes doSomething_1(=85) function
and doSomething_2(=85) function. doSomething_1(=85) does calculation to
modify 8 local variables before it calls doSomething_2(=85) function to
finish more local variables.

    I think 8 parameters are too many. I should decide to design another
class to hold 8 data members and replace 8 parameters to one class
reference.

// interface.cpp
class Data {
public:

    int a;
    int b;
    int c;
    int d;
    int e;
    int f;
    int g;
    int h;
};

void doSomething_1( Data &data );
void doSomething_2( Data &data );

void doSomething_1( Data &data ) {
    // do something
    doSomething_2( data );
}

void A::doit() {
    Data data;

    data.a = 0;
    data.b = 1;
    data.c = 2;
    data.d = 3;
    data.e = 4;
    data.f = 5;
    data.g = 6;
    data.h = 7;

    doSomething_1( data );
}

    Class Data has 8 public data members. It does not need to use getter
and setter function because it does not need to validate inbound range
on all 8 data members. doit() function takes care to modify public
data members and invokes global function doSomething_1(=85) function and
doSomething_2(=85) function.
    If I want to create more than 5 small global functions, I will want
to move them to class Data body and treat them as public member
functions, but 8 data members are still public.
    It is possible to say that public member functions may do validate
inbound range on all 8 public data members if necessary.

// interface.cpp
class Data {
public:
    void continueToDoSomething();

    void doSomething_1(); // do validate ranges
    void doSomething_2(); // do calculation
    void doSomething_3(); // do final result before return back to A.

    int a;
    int b;
    int c;
    int d;
    int e;
    int f;
    int g;
    int h;
};

void Data::continueToDoSomething() {
    doSomething_1();
}

void Data::doSomething_1() {
    // work data member -- a and b
    doSomething_2();
}

void Data::doSomething_2() {
    // work data member -- c and d
    doSomething_3();
}

void Data::doSomething_3() {
    // work data member -- e, f, g, and h
}

void A::doit() {
    Data data;

    data.a = 0;
    data.b = 1;
    data.c = 2;
    data.d = 3;
    data.e = 4;
    data.f = 5;
    data.g = 6;
    data.h = 7;

    data.continueToDoSomething();

    // after 8 local variables are complete, it modifies the final value
back to private data member =96 m_data
}

    class Data with 8 public data members and some public member
functions are hidden inside A's doit() function.
    Please let me know if you think that I should treat class Data's data
members and member functions to private because I might want to reduce
bugs if I make easy mistakes to write my code.