C / C++ / MFC

char buf[MAX_PATH+1];
DWORD res = GetModuleFileName(AfxGetInstanceHandle(),
		buf,
		MAX_PATH);
	
}

CComVariant result = buf;

CComVariant result;
result = buf; 

		CComVariant result = buf;

executes

#ifndef OLE2ANSI
	CComVariant(LPCSTR lpszSrc)
	{
		vt = VT_EMPTY;
		*this = lpszSrc;
	}
#endif

		CComVariant result2(buf);
executes the same
		CComVariant result3;
executes 
	CComVariant()
	{
		vt = VT_EMPTY;
	}

		result3 = buf;
executes 
	#ifndef OLE2ANSI
	CComVariant& operator=(LPCSTR lpszSrc)
	{
		USES_CONVERSION;
		InternalClear();
		vt = VT_BSTR;
		bstrVal = ::SysAllocString(A2COLE(lpszSrc));

		if (bstrVal == NULL && lpszSrc != NULL)
		{
			vt = VT_ERROR;
			scode = E_OUTOFMEMORY;
		}
		return *this;
	}
	#endif

This line of code from the constructor

		*this = lpszSrc;
executes the = operator code shown above. So all come out the same.

CComVariant v ("foo");
CCOmVariant v = "foo";

#include <iostream>
using std::cout;
using std::endl;

class C
{
public:
    C(int x) : m_n(x) { cout << "in constructor" << endl; }

protected:
    C(const C& rhs) : m_n(rhs.m_n) { cout << "in copy constructor" << endl; }
    const C& operator = (int x) 
        { cout << "in operator =" << endl;
          m_n=x; return *this; }
    int m_n;
};

int main()
{
    C c1 (1);
    C c2 = 2;
    return 0;
}

in constructor
in constructor

CComVariant v(CComVariant("foo")); // Uses a temporary object

#include <iostream>
 
class A {
public:
  A() { cout << "1"; }
  A(const char *) { cout << "2"; }
  A& operator=(const char *){ cout << "3"; }
  A& operator=(const A &){ cout << "4"; }

private:           // Does not compile if private!
  A(const A &) { cout << "5"; }
};
 
int main() {
   A a = "allo";
}