API design: Best way to hide data model object from user? - c++

Question

I am working on a simple API in C++ where the end user of my code will pass an instance of a UserProfile class around to various other classes for modification. The user profile has a very basic public interface, with the data stored in a private pimpl object. I then add implementation classes as friends so they can access the internal data structure, which is defined in a separate implementation file. The basic outline of this class looks as follows . . .
// For pimpl here
class UserProfileData;
class UserProfile
{
public:
/// ctor to allocate impl
UserProfile();
/// dtor
~UserProfile();
/// Do some very simple stuff with a few methods
std::string getProfileName() const;
private:
/// Use pimpl and hide impl so API user can just use simplified interface
std::unique_ptr<UserProfileData> userProfileData;
/// Allow implementation classes access to userProfileData
friend class ClassOne;
friend class ClassTwo;
};
Building a big list of friend classes doesn't feel like the most elegant solution for hiding the data from the API user. It seems a little smelly. Are there any patterns or idioms that will allow me to achieve the same goal differently?

Answer 1

Think about what you're trying to achieve by hiding the implementation details of your UserProfile class. From the sounds of it, you're probably working to decouple consumers from the internal structure of the data. Doing this with the data container may be more trouble than it's worth, though.
Purely from the consumer's perspective, there's no need to hide the details of a class like this. Consider the following data types:
struct ProfileData
{
std::string profileName;
}
struct ProfileDataWithHiddenDetails
{
std::string getProfileName();
}
The purpose of each of these types is straightforward: they're used to transmit profile information between interested parties. Each type suits this purpose well, but one is much simpler to reason about than the other.
Does getProfileName communicate with a database? Does it retrieve the profile name from a deep hierarchy of values? Is the profile name just stored in a member variable? Any of these (among others) is possible; the information has been purposefully hidden from the consumer.
The first question is: Does this information need to be hidden from the consumer? If the consumer is using the object as a data container, then abstractions would only get in the way.
If your intent is to indeed hide details of the data structure, the next question is: What information do you need to hide from the consumer? If the object is not a simple data aggregator, consumers will need to adopt a different mindset when using it.
Abstractions can make it easier to reason about a system, but they can also make it harder. Try to abstract the behavior in your API rather than the data.
Example
Imagine ProfileDataWithHiddenDetails::getProfileName actually retrieves the profile name from a rich object model that you wanted to keep hidden from consumers. Something like:
std::string getProfileName
{
return objectModel.getRoot().getUserProfile().profileName;
}
These details don't need to be hidden in the implementation of getProfileName. Perhaps there was an API function call that returned the profile data:
ProfileDataWithHiddenDetails getProfileData()
{
return ProfileDataWithHiddenDetails(objectModel);
}
Instead of returning an abstraction, this API function could handle the abstraction itself:
ProfileData getProfileData()
{
auto profileName = objectModel.getRoot().getUserProfile().profileName;
return ProfileData { profileName };
}