VS2012 - Class Interface Design: Private Member Funcs Positioning / Hiding

Question

In VS, when you type "class." you are presented with a list of functions you can call. Having to look through a list of 15-20 functions, half or more of which being members is not nice.

I'm extremely interested in finding a system that will hide private member functions or move them to the end of the list, so the user doesn't have to scroll through a list of locked functions.

I have four design types: 1) Namespace method hiding 2) Class based method hiding 3) pimpl version 4) _ prefix

Here is the code for clarity:

#pragma once
#include <memory>

using namespace std; // ignore the fact this is global here

struct Hide_Test_Data
{
    int value;
};

namespace Hide_Test_Private_Member_Ns
{
    void private_function(Hide_Test_Data& data) {}
};

class Hide_Test_Methods
{
public:
    Hide_Test_Methods() {}
    void private_function(Hide_Test_Data& data) {}
};

class Hide_Test_Methods_Alt
{
public:
    Hide_Test_Methods_Alt() {}
    void private_function() {}
private:
    Hide_Test_Data htd_;
};

class Hide_Test
{
public:
    Hide_Test() {}

    void public_function() 
    {
        _private_function(); // member function prefixed with _ 
        Hide_Test_Private_Member_Ns::private_function(htd_); // namespace version
        htm_.private_function(htd_); // subclass version  (no private data)
        pimpl->private_function(); // pimpl version (with private data)
    }

private:
    Hide_Test_Data htd_; // class to hold data 
    Hide_Test_Methods htm_; // class to hold methods
    void _private_function() {}; // _ prefixed member function
    unique_ptr<Hide_Test_Methods_Alt> pimpl;
};

Note:

• The unique_ptr Hide_Test_Methods_Alt version has member data which the standard one doesn't. Both could be implemented in either way.

• The _ prefix doesn't hide the member data, but it does move it to the end of the list. This has the advantage of allowing user to see the private functions if they are interested. My main goal is not to hide the private member functions, just to move them out of the way.

• Prefixing data with _ 'should' be safe out of global scope according to the standard as long as it is followed with a lowercase letter.

Which of these designs would be more acceptable in general? I imagine I could work with all four of these design types comfortably, but I would rather hear some input on some of the pros and cons I may not have thought of.

Pimpl uses a pointer to ease copying the member data. In the cases where I don't need to copy the member data, is just using a class better or worse?

I have done some research and found a few related threads in this forum:

Hiding private data members? (C++) - this one points out the pimpl idiom (which I added to my examples above).

How to hide private members of a Class? - talks about VS intellisense not hiding private members

Why does Visual Studio's intellisense show private members and functions? - gives an #ifdef solution that I don't really like the idea of.

I think this question is different enough from the others presented to be worthy posting. Thanks as always.

Answer 1

Generally a pimpl pattern is applied when you want to be able to change implementations at link time and as such must be a pointer Here you don't want the overhead, so you could consider an inner class and an instance of that class as opposed to a pointer:

class fewfunctions
{
    class manyfunctions
    {
    public:
        int a1() { return 0; }
        int a2() { return 0; }
        int a3() { return 0; }
        int a4() { return 0; }
        // ... many more
    };
public:
    int b() { return a.a1() + a.a2() + a.a3() +a.a4(); }
private:
    manyfunctions a;
};

Only b will show up as a function (a shows up as locked)