Does that mean that the line 'myMemberString = ""; is waste?

Yep. That's not a constructor call, that's an assignment that will be performed after construction.

Probably cheap anyway, but 100% waste.

See http://gcc.godbolt.org/ , enter your code and see asm output for the various compilers. Results depends on compiler version and optimization settings. Recent gcc and clang managed to eliminate separate assignment call, but older gcc couldn't do it.

And how about pointers? (which I currently always initialize to 'nullptr' in the constructor)

Raw pointers should be treated same way as booleans, i.e. explicitly initialize it. Either with value, or make it zero initialized with default initialization. No need to write 'nullptr' or '0' explicitly:

class Foo
{
    bool flag;
    void* ref;

    Foo()
    : flag(), ref()
    { }
};

Do you mean () instead of writing out nullptr.
In code, would that be the following (in the constructor implementation, I don't do it inline):

The two are not equivalent in the constructor implementation. In the initializer list, however, they produce equivalent results; the first is value-initialization which for pointers means its value is set to the null pointer, while the second (explicitly) initialises it with a null pointer. Start using the initializer list; some things just cannot be initialized in the constructor body.

If you don't initialize a member in the initializer list, its default constructor will be executed as a part of the initialization of the object. Once the initializer list is executed (including the default constructor for members you don't explicitly initialize) the constructor body is executed. The difference between constructing a member in the initializer list and "constructing" it in the body of the containing class' constructor is; the former directly calls the proper constructor, while the latter default constructs the object and then calls the assignment operator of whatever you're assigning to it.

If the member type cannot be default initialized, you must initialize it in the constructor body. If the member type is expensive to default construct, then you pay for unnecessary default initialization and then an assignment to override the value from the default constructor.

edit: To expand on the above a little more. Once the constructor body starts executing, all members have had one of their constructors called and they are all properly constructed. I mentioned in my last post that some things cannot be initialized other than in the initializer list. For example, the base class in an inheritance tree must be called from the initializer list; objects without a default constructor cannot be default constructed; const objects cannot be assigned to in the constructor body since that would change a const object.

myMemberString = "";

This one falls under one of the somewhat quirky parts of the language. This specific case invokes the constructor that accepts a char* parameter and the default allocator parameter.

When an object is created and immediately assigned, and when the constructor also takes a parameter of a compatible type, a near-universal early optimization was to just call the constructor rather than both the constructor and the assignment.

When the language was standardized back in 1998, that optimization was codified and turned into a requirement, and it remains in the standard today. It is under the section called a converting constructor, partially covered under the 'copy initialization' blanket, and has some interesting rules due to its history. The rule of how and when the constructor is used directly versus when the assignment operator is used can also be modified by the 'explicit' keyword.

cppreference has this little gem explaining it, which applies in this case:

struct A
{
  A(int) { } // converting constructor
  A(int, int) { } // converting constructor (C++11)
  ...
};
...
A a1 = 1; // OK: copy-initialization selects A::A(int)
A a2(2); // OK: direct-initialization selects A::A(int)
A a3 {4, 5}; // OK: direct-list-initialization selects A::A(int, int)
A a4 = {4, 5}; // OK: copy-list-initialization selects A::A(int, int)
A a5 = (A)1; // OK: explicit cast performs static_cast