long _stdcall ff(char *value);

cobj::cobj(char *value);

long _stdcall ff(char *value)
{
    cobj xx = value; //вызывается cobj::cobj(char *value)
    ...
    return 0;
}

long _stdcall ff(cobj value) // cobj::cobj(char *value) не вызывается. Да что там - вообще ничего не вызывается.
                             // Просто в приватные переменные записывается что попало.
{
    ...
    return 0;
}

inline operator char* () { return m_str; }

inline operator const char* () const { return m_str; }

M>long _stdcall ff(char *value);
M>

M>cobj::cobj(char *value);
M>

M>long _stdcall ff(char *value)
M>{
M>    cobj xx = value; //вызывается cobj::cobj(char *value)
M>    ...
M>    return 0;
M>}
M>

M>long _stdcall ff(cobj value) // cobj::cobj(char *value) не вызывается. Да что там - вообще ничего не вызывается.
M>                             // Просто в приватные переменные записывается что попало.
M>{
M>    ...
M>    return 0;
M>}
M>

M>... можно конечно использовать первый способ и не ломать голову, НО интересно же, да и красивше

long _stdcall ff(cobj value) 
{    
        ...
    return 0;
}

ff("teststring");

// cobj.h
class cobj
{
public:
    cobj() : m_buffer(0) {}
    cobj(const char *value) : m_buffer(0)
    {
       if( value ) 
       {        
          m_buffer = strcpy(new char[strlen(value)+1], value);
       }
    }
    cobj(const cobj &obj) : m_buffer(0)
    {
       if( obj.m_buffer ) 
       {        
          m_buffer = strcpy(new char[strlen(obj.m_buffer)+1], obj.m_buffer);
       }
    }
    cobj& operator = (const cobj &obj)
    {
       if( &obj == this) return *this;
       delete [] m_buffer;
       m_buffer = 0;
       if( obj.m_buffer ) 
       {        
          m_buffer = strcpy(new char[strlen(obj.m_buffer)+1], obj.m_buffer);
       }
       return *this;
    }
    ~cobj()
    {
        if( m_buffer ) delete [] m_buffer;
    } 
private:
    char *m_buffer;
};
// ff.h
#include "cobj.h"
extern long ff(cobj value);

// ff.cpp
long ff(cobj value)
{
   ...
   return sizeof(value);   
}
// main.cpp
#include "ff.h"
int main()
{
   ff("test"); && и что даже так не вызывается cobj::cobj(const char *)?
   return 0;
}

cobj xx = value;

long _stdcall ff(cobj value)
{
   //здесь переменные value содержат всякую ерунду, т.е. value указывает непонятно куда
   return 0;
}

int main()
{
   ff("test"); && и что даже так не вызывается cobj::cobj(const char *)?
   return 0;
}

M>long _stdcall ff(cobj value)
M>{
M>   //здесь переменные value содержат всякую ерунду, т.е. value указывает непонятно куда
M>   return 0;
M>}

extern "C" HRESULT __stdcall f2s( /*[in]*/ BSTR pszCmdLine );

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine, int       nCmdShow)
{
    // TODO: Place code here.

    BSTR s = ::SysAllocString(L"xyz");
    f2s( s );
    ::SysFreeString(s);
    return 0; 
}

extern "C" HRESULT __stdcall f2s( /*[in]*/ CComBSTR pszCmdLine )
{ 
    pszCmdLine.Detach(); // чтобы "обмануть" компилятор. А если забудешь?! Да не таком простом примере.
    return 0;
}

extern "C" HRESULT __stdcall f2s( BSTR pszCmdLine )
{ 
    CComBSTR& szCmdLine = *(CComBSTR*) &pszCmdLine;

...

    return 0;
}

Спасибо всем за участие.