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: 
If you do not want to introduce another class, you can shrink the circle of friendship and make `Bar`'s constructor `Foo`'s friend. It requires `Bar`'s definition to be available to `Foo`, and it still gives `Bar`'s constructor unrestricted access to `Foo`'s private implementation:

```
struct Foo;

struct Bar {
   Foo* f;
   Bar();
   ~Bar();
};

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

Bar::Bar() : f(new Foo()) {
}

Bar::~Bar() {
    delete f;
}

```

This does not achieve exactly what you want, but it makes friendship a lot more targeted.
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.