Comments by Southmountain (Top 155 by date)

In your example you have two Clone methods. But as both have no parameters (only different return types), there is no method override being done. C# allows you to keep the IClonable.Clone method, however it requires you to place the name of interface before the method name. As interfaces are public and the method is explicitly declared with the name of the interface there is no need for a access modifier as it is public by design.

Use the LockBits method to lock an existing bitmap in system memory so that it can be changed programmatically. You can change the color of an image with the SetPixel method, although the LockBits method offers better performance for large-scale changes.

template <class T>
class TLineApproximator  
{
public:
	//! \name Structures and typedefs
	//@{
	//! 2D homogenous point
	struct SHomog
	{
	public:
		SHomog(T _x=0, T _y=0, T _w=1)	{ x=_x; y=_y; w=_w;};	
			T x;
			T y;
			T w;
     	};
//skip few lines

Warning	C4091	'typedef ': ignored on left of 'Crosshair' when no variable is declared	NTGraph	c:\demo_temp\ntgraph_src\ntgraphctl.h

extern "C"{
//implementationint function_name(int,int)
{  
//code logic here
}
}

'void printError(TCHAR *)': cannot convert argument 1 from 'const wchar_t [12]' to 'TCHAR *'

	// Get and display the system directory. 
	if (!GetSystemDirectory(infoBuf, INFO_BUFFER_SIZE))
		printError(TEXT("GetSystemDirectory"));

class CString
{
    // Members
protected:
    char *m_str;

    // Constructor/Destructor
public:
    CString() 
    { 
        m_str = NULL;
    }
    CString(char *szInputSource) 
    { 
        m_str = NULL;
        if (szInputSource)
            Copy(szInputSource);
    }
    CString(const CString &szInputSource) 
    { 
        m_str = NULL;
        Copy(szInputSource.GetData());
    }
    ~CString()
    {
        Empty();
    }

// Methods
public:
    void operator +=(CString &szAdditionalString)
    {
        Append(szAdditionalString);
    }

    void operator +=(char *szAdditionalString)
    {
        Append(szAdditionalString);
    }

    void operator +=(char sAdditionalChar)
    {
        Append(sAdditionalChar);
    }

    CString operator +(CString &szAdditionalString)
    {
        CString szTemp = *this;
        szTemp.Append(szAdditionalString);
        return szTemp;
    }

    CString operator +(char *szAdditionalString)
    {
        CString szTemp = *this;
        szTemp.Append(szAdditionalString);
        return szTemp;
    }

    CString operator +(char sAdditionalChar)
    {
        CString szTemp = *this;
        szTemp.Append(sAdditionalChar);
        return szTemp;
    }

// binary + operator (global, with const parameters)
    friend CString operator+(const CString &sz1, const CString &sz2)
    {
        CString s = sz1;
        s += (CString&)sz2;
        return s;
    }

    friend CString operator+(CString &sz1, const char sz2)
    {
        CString s = sz1;
        s += (char)sz2;
        return s;
    }

    friend CString operator+(const char *sz1, CString &sz2)
    {
        CString s = (char*)sz1;
        s += sz2;
        return s;
    }