different ways of declaring classes

I have a class, within which I have the need for several different data structures. I have no use for these structures outside of the class, so I've been declaring them like this:

Code:

//an obviously simplified version
class myClass
{
     struct dataStructure
     {
          int data;
          char letter;
     }

     dataStructure foo;
}

A few questions
1) this does prevent dataStructure from being used outside of myClass, correct?
2) are there any performance problems with doing it this way?
3) ...other concerns about doing it this way?

1) yes and no. in your code yes because the outer class is a class and as such the inner struct is private to it as there is no access specifier. had it been in the public section then it could have been used like so...
outer_class::inner_class myobj;

2)no. its good usual pseudo-data hiding practice.

3) none but look into the pimpl idiom and the bridge design pattern. Good info on pimpl idiom here

Stoned_coder, are you sure you posted the right link? I searched for both "pimpl" and "bridge" on that site, and found neither. Thanks for the speedy response on the question, though.

start at number 1 and work thru. u will learn more than u can imagine. There is plenty of info on pimpl idiom there. search for compilation firewall. For bridge pattern try google. visit pattern repository. good articles also on codeproject.

look at 24 and 28 for starters

private member will prevent dataStructure from being used outside of yourClass

I read about the pimple idiom. From what I gathered it is just a way to hide the details of a class implementation to improve compile times and (dependencies?). Is this correct. Very nearly over my head type of stuff. Ohh one question suppose you have a pointer that points to the class with the members you are hiding what then is the syntax for accessing these members. Also why is it called the pimple idiom?

In the name, 'p' stands for pointer, and 'impl' for implementation - comes out to pimpl. Someone just wanted something pronounceable (though personally, I usually use the name 'data_ptr' instead of 'pimpl').

The implementation structure should be a private member. Basically, it is a collection of all (or most) of your member data, and private utility functions (with some exceptions). Nothing outside the class should be able to access it, only the class implementation itself. Even derived classes (in most casses) should not have access to this information. To operate on the class, you just use the provided interface.