Q:

Initializing.. which one is more efficient?

I have the following question. Which one of these is better that should be followed and why?
string strMyString = "SampleString";

or
string strMyString("SampleString");

Thanks in advance.

A:

I answered it here
One thing i put into this answer here: Neither is using any assignment operator.
Short explanation for the string specific thing though. std::string has a constructor taking one argument that accepts char const*:
// simplified to a normal class declaration. std::string actually
// is a template instantiation. 
class string {
public:
    string(char const* str) {
        // copy over...
    }
};

Now you see that has a constructor taking a pointer to character(s). So that it can accept a string literal. I think the following case is obvious then:
string s("hello");

It will call the constructor directly and initialize s thereby. This is called direct initialization. 
The other way of initializing a variable is called copy initialization. The Standard says for the case of copy initialization where the initializer has not the type of the object it is initializing, the initializer is converted to the proper type. 
// uses copy initialization
string s = "hello";

First, let's state the types

s has type std::string
"hello" is an array, which in this case again is handled like a pointer. We will therefor consider it as char const*. 

The compiler looks for two ways to do the conversion.

Is there a conversion constructor in std::string?
Does the initializer has a type that has a conversion operator function returning a std::string?

It will create a temporary std::string by one of those ways that is then used to initialize the object s by using std::string's copy constructor. And it sees std::string has a conversion constructor that accepts the initializer. So it uses it. In the end, it is effectively the same as 
std::string s(std::string("hello"));

Note that the form that is used in your example that triggered all that
std::string s = "hello";

defines an implicit conversion. You can mark the constructor taking the char const* as explicit for your types if you wonder about the initialization rules for your stuff, and it will not allow to use the corresponding constructor as a conversion constructor anymore:
class string {
public:
    explicit string(char const* str) {
        // copy over...
    }
};

With that, initializing it using a copy initialization and a char const* actually is forbidden now (and in various other places)!
Now, that was if the compiler does not support elision of temporaries at various places. The compiler is allowed to assume that a copy constructor copies in this context, and can eliminate the extra copy of the temporary string, and instead construct the temporary std::string directly into the initialized object. However, the copy constructor must be accessible in particular. So, the copy initialization is invalid if you do this
class string {
public:
    explicit string(char const* str) {
        // copy over...
    }

private: // ugg can't call it. it's private!
    string(string const&);
};

Now actually, only the direct initialization case is valid. 

A:

Compile both, look at the assembler.  The first is one fewer instruction ... 
; 9    :    std::string f("Hello");

    push    OFFSET ??_C@_05COLMCDPH@Hello?$AA@
    lea ecx, DWORD PTR _f$[esp+80]
    call    DWORD PTR __imp_??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@PBD@Z

; 10   :    std::string g = "Hello";

    push    OFFSET ??_C@_05COLMCDPH@Hello?$AA@
    lea ecx, DWORD PTR _g$[esp+80]
    mov DWORD PTR __$EHRec$[esp+88], 0
    call    DWORD PTR __imp_??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@PBD@Z

... but that's an artifact, because it was the first one the compiler saw.  Change the code by swapping the order:
; 9    :    std::string g1 = "Hello";

    push    OFFSET ??_C@_05COLMCDPH@Hello?$AA@
    lea ecx, DWORD PTR _g1$[esp+136]
    call    DWORD PTR __imp_??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@PBD@Z

; 10   :    std::string f1("Hello");

    push    OFFSET ??_C@_05COLMCDPH@Hello?$AA@
    lea ecx, DWORD PTR _f1$[esp+136]
    mov DWORD PTR __$EHRec$[esp+144], 0
    call    DWORD PTR __imp_??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@PBD@Z

... and lo and behold, the second is one fewer instruction. 
We also see that this compiler (Microsoft VC++ 2005, Release settings) generated the same assembler for both versions.  So it makes no difference in this compiler, and you can prove it.

