I have a class that has some members (data and functions) that I do not want
to be public.  However, I do want these private members to be accessible to
objects of the same class.

    Example
    =======

    A a, b;  // 'a' and 'b' are objects of the same class
    C c;     // 'c' is not

    c = a.p();  // No; 'p' is private

    b = a.p();  // Okay; 'b' belongs to the same class as 'a'

Would a simple wrapper do what you want, or are you attempting something
else?

class A
{
   int p() { return 0; }
   int n;

public:

   void pCall( A& a ) { n = a.p(); }

But in the example you have given, member functions of b can access
private members of a, and member functions of c can't. So it should be
easy to do what you want. It's just that the syntax you have written
above is not the right way to do it.

#ifndef EXAMPLE_HPP
#define EXAMPLE_HPP

class Example
{
private:
        // Inner class that is used to pass
        // data from Example object to Example
        // object.
        class DataWrapper
        {
        public:
                int _x;
                DataWrapper(int x)
                {
                        _x = x;
                }
        };

public:
        Example(int exampleX);
        Example& operator=(const DataWrapper& data);

        DataWrapper p(int x);

        int exampleX() { return _exampleX; }

private:
        int _exampleX;

And then there's this bit of code to demonstrate it:
#include <iostream>

using namespace std;

#include "Example.hpp"

class OtherExample
{
public:
        // This line creates a compiler error.
        // ! void print(const Example::DataWrapper& data) {}

        test = test2.p(50);

        cout << test.exampleX() << endl;

        // One possible pitfall: You can use this method
        // to gain access to the public members of the
        // private nested class.
        int z = test.p(10)._x;

        cout << z << endl;

        return 0;

To clarify:

private members are visible to any function within the same class, or
any friend function, or any function in a friend class.

protected members are the same as private, except they can also be
accessed by its derivatives.

"RedXV" <jeremy.pridem...@gmail.com> wrote ...