Long delegation chains in C++
===

In my several recent projects I used to implement architectures where long delegation chains are a common thing.

Dual delegation chains can be encountered very often:

	bool Exists = Env->FileSystem->FileExists( "foo.txt" );

And triple delegation is not rare at all:

	Env->Renderer->GetCanvas()->TextStr( ... );

Delegation chains of higher order exist but are really scarce.

In above mentioned examples no NULL run-time checks are performed since the objects used are always there and are vital to the functioning of the program and
explicitly constructed when execution starts. Basically I used to split a delegation chain in these cases:

**1)** I reuse the object obtained through a delegation chain:


    clCanvas* C = Env->Renderer->GetCanvas();
    C->TextStr( ... );
    C->TextStr( ... );
    C->TextStr( ... );


**2)** An intermediate object somewhere in the middle of the delegation chain should be checked for NULL before usage. Eg.

	clCanvas* C = Env->Renderer->GetCanvas();

	if ( C ) C->TextStr( ... );

I used to fight the case (2) by providing proxy objects so that a method can be invoked on non-NULL object leading to an ``empty`` result.

**My questions are:** 

 1. Is either of cases (1) or (2) a pattern or an antipattern?
 2. Is there a better way to deal with long delegation chains in C++?

Here are some pros and cons I considered while making my choice:

**Pros:**

 - it is very descriptive: it is clear out of 1 line of code where did the object came from
 - long delegation chains look nice

**Cons:**

 - interactive debugging is labored since it is hard to inspect more than one temporary object in the delegation chain



