Question: I am working on some code, where I encountered a situation similar to this one:

```
struct Bar;

struct Foo{
    friend struct Bar;
private:
    Foo(){}
    void f(){}
    void g(){}
};

struct Bar {
   Foo* f;
   Bar()  { f = new Foo();}
   ~Bar() { delete f;}
};

int main(){
  Bar b;
}

```

I would prefer to have `Bar` not as `friend` of `Foo`, because besides `Foo`s constructor `Bar` does not need access to any of `Foo`s private methods (and thus should not have access). Is there a way to allow only `Bar` to create `Foo`s without making them friends?

**PS**: realized that the question might not be 100% clear. I don't mind if it is via friends or not, just the fact that all `Bar` has access to all private methods is disturbing me (which is usually the case with `friends`) and that is what I want to avoid. Fortunately none of the answers given so far had a problem with that lousy formulation.

Answer: 
This is precisely what the [attorney-client](https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Friendship_and_the_Attorney-Client) idiom is for:

```
struct Bar;

struct Foo {
    friend struct FooAttorney;
private:
    Foo(){}
    void f(){}
    void g(){}
};

class FooAttorney {
  static Foo* makeFoo() { return new Foo; }
  friend struct Bar;
};

struct Bar {
   Foo* f;
   Bar()  { f = FooAttorney::makeFoo();}
   ~Bar() { delete f;}
};

int main(){
  Bar b;
}

```

In a code imitates life fashion, the class declares an attorney that will mediate the secrets it's willing to share with the selected parties.
One way that occurred to me was to have an internal `class` that makes `Bar` its friend so only `Bar` can create it and that internal `class` can be used as an additional parameter to `Foo` constructor so only the `class`'s friends can invoke it.

```
class Foo
{
public:
    // only friends of the special key can invoke the constructor
    // or any member function that includes it as a dummy parameter
    class special_key {friend class Bar; special_key(){}};

    // making special_key a dummy parameter makes sure only friends of
    // the special key can invoke the function
    Foo(special_key) {}
    void f(){}
    void g(){}
};

class Bar
{
public:
    // only Bar functions can create the special key
    Bar() { f = std::make_unique<Foo>(Foo::special_key()); }

private:
    std::unique_ptr<Foo> f;
};

```

As well as restricting access to specific functions this technique also allows the use of smart pointer `make` functions which direct friendship does not.