C / C++ / MFC

// tstl.h - header file for TCHAR equivalents of STL string classes
 
#pragma once
 
namespace std
{
#if defined UNICODE || defined _UNICODE
 
    typedef wstring         tstring;
 
    typedef wstringbuf      tstringbuf;
    typedef wstringstream   tstringstream;
    typedef wostringstream  tostringstream;
    typedef wistringstream  tistringstream;
 
    typedef wstreambuf      tstreambuf;
 
    typedef wistream        tistream;
    typedef wiostream       tiostream;
 
    typedef wostream        tostream;
 
    typedef wfilebuf        tfilebuf;
    typedef wfstream        tfstream;
    typedef wifstream       tifstream;
    typedef wofstream       tofstream;
 
    typedef wios            tios;
 
#   define tcerr            wcerr
#   define tcin             wcin
#   define tclog            wclog
#   define tcout            wcout
 
#else // defined UNICODE || defined _UNICODE
 
    typedef string          tstring;
 
    typedef stringbuf       tstringbuf;
    typedef stringstream    tstringstream;
    typedef ostringstream   tostringstream;
    typedef istringstream   tistringstream;
 
    typedef streambuf       tstreambuf;
 
    typedef istream         tistream;
    typedef iostream        tiostream;
 
    typedef ostream         tostream;
 
    typedef filebuf         tfilebuf;
    typedef fstream         tfstream;
    typedef ifstream        tifstream;
    typedef ofstream        tofstream;
 
    typedef ios             tios;
 
#   define tcerr            cerr
#   define tcin             cin
#   define tclog            clog
#   define tcout            cout
 
#endif // defined UNICODE || defined _UNICODE
} // namespace std

// headerfile.h
extern tistream& tcin;
#endif
 
 
// cppfile.cpp
#ifdef _UNICODE
tistream& tcin = wcin;
#else
tistream& tcin = cin;
#endif

// headerfile.h
#ifdef _UNICODE
__declspec(selectany) tistream& tcin = wcin;
#else
__declspec(selectany) tistream& tcin = cin;
#endif

#include <string>
#ifdef _UNICODE
typedef std::wstring tstring;
#else
typedef std::string tstring;
#endif // _UNICODE

<br />
dat_file.write(person.FullName, sizeof(char)*NAME_SIZE);<br />
dat_file.write((char*) &person.Age, sizeof(int));<br />

<br />
dat_file.read(person.FullName, sizeof(char)*NAME_SIZE);<br />
dat_file.read((char*) &person.Age, sizeof(int));<br />

long getFileSize(fstream * tempFile)<br />
{<br />
	long begin, end;<br />
	begin = tempFile->tellg();<br />
	tempFile->seekg (0, ios::end);<br />
	end = tempFile->tellg();<br />
	return end-begin;<br />
}

long getFileSize(fstream * tempFile)
{
    long begin, end;
    begin = tempFile->tellg(); // save current position
    tempFile->seekg (0, ios::end);
    end = tempFile->tellg(); // get eof position
    tempFile->seekg (begin); // restore saved position
    return end;
}

// ***************************************
// Example: Dynamic Multidimensional Array
// ***************************************

// We want both array dimensions to be allocated dynamically and
// to be able to reference an element as x[i][j]
// Here's how to do it...

// ***********
// MFC Version
// ***********

// Array of ints
typedef CArray <int, int> CIntArray;

// Array of arrays of ints
typedef CArray <CIntArray, CIntArray&> CMultiIntArray;

void TraceDynamicArray(const unsigned int rows, const unsigned int columns)
{
  CMultiIntArray aTest;
  

 // Allocate number of rows
  aTest.SetSize( rows );
  

 // For each row
  for (int row = 0; row < aTest.GetSize(); row++)
  {
    // Allocate number of columns
    aTest[row].SetSize( columns );
    

   // For each column
    for (int column = 0; column < aTest[row].GetSize(); column++)
    {
      // Assign a value
      aTest [row] [column] = 10 * row + column;
      

     // Trace it
      afxDump << aTest [row] [column] << "\t";
    }

   afxDump << "\n";
  }
}

CArray<CArray<int>> array;
array.SetSize(number_of_rows);
for (int row = 0; row < number_of_rows; row++) {
  array[row].SetSize(number_of_columns);
}
//...
for (int row = 0; row < array.GetSize(); row++) {
  for (int col = 0; col < array[row].GetSize(); col++) {
    array[row][col] = 0; //...
  }
}

Healdp wrote:

Detecting the presence of a valid connection seems to be **** HARD !