Sense check: construction / deconstruction

[Jordan Wilson via Digitalmars-d-learn]

I have the following code:
import std.stdio;
import std.typecons;
import d2sqlite3;
class A {
    Database db;
    this ( Database d) {
        db = d;
    }
}

class B {
    Database* db;
    this ( Database* d) {
        db = d;
    }
}

void main() {
    auto db = Database(":memory:");
    auto a = new A(db); // gives message:
                        // Error: clean-up of Database incorrectly
                        // depends on destructors called by the GC

    auto b = new B(&db); // no message
    auto c = scoped!A(db); // no message
}

Assumption 1: "a" gives me an error message due to the fact that 
proper clean up of db depends on a being collected by the GC, and 
this behavior is being dis-allowed through use of the idiom 
https://p0nce.github.io/d-idioms/#GC-proof-resource-class?
The relevant function calling the error message is:
void ensureNotInGC(T)(string info = null) nothrow
{
    import core.exception : InvalidMemoryOperationError;
    try
    {
        import core.memory : GC;
        cast(void) GC.malloc(1);
        return;
    }
    catch(InvalidMemoryOperationError e)
    {
        // error message here
    }
}

Assumption 2: "b" gives me no error messages because the class B 
uses pointers, which moves it from relying on GC, to being 
manually free?

Assumption 3: "c" gives me no error messages because...well, I 
don't really understand why, maybe because c is in the same scope 
as db?

Thanks,

Jordan