C / C++ / MFC

HRESULT hr;

BSTR        header_BSTR = ::SysAllocString(L"&w&b&b&p");
VARIANT     header_variant;

VariantInit(&header_variant);
V_VT(&header_variant)   = VT_BSTR;
V_BSTR(&header_variant) = header_BSTR;

BSTR        footer_BSTR = ::SysAllocString(L"&d &t");
VARIANT     footer_variant;

VariantInit(&footer_variant);
V_VT(&footer_variant)   = VT_BSTR;
V_BSTR(&footer_variant) = footer_BSTR;

long index;

SAFEARRAYBOUND  parameter_array_bound[1];
SAFEARRAY       *parameter_array = NULL;

parameter_array_bound[0].cElements = 2;
parameter_array_bound[0].lLbound   = 0;

parameter_array = SafeArrayCreate(VT_VARIANT,1,parameter_array_bound);

index = 0;
hr = SafeArrayPutElement(parameter_array,&index,&header_variant);

index = 1;
hr = SafeArrayPutElement(parameter_array,&index,&footer_variant);

VARIANT parameter;
VariantInit(&parameter);
V_VT(&parameter)    = VT_ARRAY | VT_BYREF;
V_ARRAY(&parameter) = parameter_array;

hr = _Browser->ExecWB(OLECMDID_PRINT,OLECMDEXECOPT_DONTPROMPTUSER,&parameter,NULL);

if (!SUCCEEDED(hr)) {
    VariantClear(&header_variant);
    VariantClear(&footer_variant);
    if (parameter_array != NULL) {
        SafeArrayDestroy(parameter_array);
    }
}

char buffer[200] = {0};
std::string str = "";
int i = 9;
sprintf(buffer, "\n\nThis is number: %d\n\n", i);
str = buffer;
printf(str.c_str());

string_smart Format(cstr szText,...)
{
	cstr  szPtr=szText;
	size_t lLen;
	//Calculating Average length
	for (lLen=0;*szPtr; ++szPtr,(*szPtr=='%') ?lLen+=10:lLen++);

	string_cstr strRes(++lLen);
	
	va_list marker;
	va_start( marker, szText);     
	
	while (_vsnprintf(strRes.buffer(),strRes.buffer_size()-1,szText,marker) <0 ) 
		strRes.reserve(strRes.buffer_size()*2);

	//_ASSERTE( _CrtCheckMemory( ));
	strRes.buffer()[strRes.buffer_size()-1]='\0';	//Don't remove this line!
	strRes.recalc_len();						
									

	va_end( marker );              
	
	return strRes;
}

#include <string>
#include <sstream>
 
ostringstream strm;
string strMarks;
 
  strm << "I got " << marks << " marks" << ends;
  strMarks = strm.str();

#include <string>
#include <sstream>
std::ostringstream strm;
strm << "I got " << marks << " marks" << std::ends;
std::string strMarks = strm.str();

<br />
ULONG_MAX,<br />
LONG_MAX, LONG_MIN...<br />

int x = 5;  // initializes a variable int to value 5.
int* px = &x; // initializes a "pointer to int" pointing to the physical address of 5.
int** ppx = &px; // initializes a pointer to the pointer px with the address of px.

// now to get the value 5, you need to "de-reference" the pointers.
int x_val_raw = x;
int x_val_from_px = *px;
int x_val_from_ppx = **ppx;

// now all those terms should equal 5.

int* px = &x; // initializes a "pointer to int" with the physical address of x.
-------   --
 |        |
 |        |- read "Address of x"
 |
 |- read "a variable 'px' of type 'pointer to int'"

func(CString* pszString, CString& szAnotherString)
{
  pszString->Format("A String");
  szAnotherString.Format("Some String);
}

int main(int argc, char* argv[])
{
	int x = 5;
	printf("\nThe value x initially has the value %d", x);
	unsigned long physical_address_of_x = reinterpret_cast<unsigned long>(&x);
	int& reference_to_x = x;
	int* pointer_to_x = reinterpret_cast<int*>(physical_address_of_x);
	// change the "reference to x" and watch what happens to x.
	printf("\n\nWe are now setting reference_to_x = 12\n");
	reference_to_x = 12;
	printf("\nThe value x is located at 0x%X and now has the value %d.", physical_address_of_x, x);
	printf("\nThe reference to x is located at 0x%X and has the value %d.", &reference_to_x, reference_to_x);
	printf("\nThe pointer to x is located at 0x%X and points to location 0x%X.", &pointer_to_x, pointer_to_x);
	printf("\nThe pointer to x, when de-referenced yeilds the value %d\n\n", *pointer_to_x);

	return 0;
}