C / C++ / MFC

//Base.h
class Base {
};

//Sub1.h
#include "Base.h"
class Sub1 : public Base {
};

//Sub2.h
#include "Base.h"
class Sub2 : public Base {
};

//Main.cpp
#include "Sub1.h"
#include "Sub2.h"

int main() {
	Sub1 s1;
	Sub2 s2;
	//do stuff with the classes
	return 0;
}

// File A.h
#define MY_GUARD_A_H

class A {
  // ...
};
// end of file A.h


// File A.cpp
#ifndef MY_GUARD_A_H
#include "A.h"
#endif

// ...

//end of file A.cpp

Andrew Brock wrote:

it would be rather silly to not do it that way

// file A.h

class A {
  // ...
};
// end f file A.h

// file B.h
#include "A.h"

class B : public A {
  // ...
};
// end of file B.h

// file B.cpp
#include "B.h"
#include "A.h"

// ...

// end of file B.cpp

void CustomPrintDlg::OnLandscapeChecked()
{
      // set the current Devmode to landscape
      LPDEVMODE pDevMode = GetDevMode();
      pDevMode->dmOrientation = DMORIENT_LANDSCAPE;
      GlobalUnlock(pDevMode);
}

typedef struct {
	wchar_t szCol1[4];
	whcar_t szCol2[4];
} DatabaseRow;

DatabaseRow drTable[2] = {
	{ L"row", L"one" },
	{ L"row", L"two" }
};

typedef struct {
	DWORD nFieldLen;
	BYTE pFieldData[]; //Note: this is a 0 sized array and may generate a compiler warning. It is perfectly safe if you use it correctly
} DatabaseField;

typedef struct {
	DWORD nColumns;
	DatabaseField *pColumns[]; //Another 0 sized array
} DatabaseRow;
//Allocate some memory for the table
int nColumns = 3;
DatabaseRow *pRow = (DatabaseRow *)malloc(sizeof(DatabaseRow) + sizeof(DatabaseField) * nColumns); //This is where the 0 sized array is useful, only the size of nColumns is counted in sizeof(DatabaseRow)

typedef struct _DatabaseField
{
	DWORD nFieldLen;
	wchar_t pFieldData[];
} DatabaseField;

typedef struct _DatabaseRowEx
{
	DWORD nColumns;
	DatabaseField *pColumns[]; 
} DatabaseRowEx;

int nColumns = 3, x = 0, rowz = 1;

	wchar_t *row1elems[] = {L"aaa", L"bbb", L"ccc"};
	wchar_t *row2elems[] = {L"111", L"222", L"333"};
	DatabaseRowEx *pRow = (DatabaseRowEx *)malloc(sizeof(DatabaseRowEx) + 
		sizeof(DatabaseField) * nColumns * rowz);
	wprintf(L"Row 1: ");
	for(x = 0; x < nColumns; x++)
	{
		pRow[0].pColumns[x] = (DatabaseField *)malloc(sizeof(wchar_t *) * 
			wcslen(row1elems[x]) + 1);
		wcscpy((wchar_t *)pRow[0].pColumns[x], row1elems[x]);
		wprintf(L" [ %s ] ", pRow[0].pColumns[x]);
	}
	wprintf(L"\r\n");

rowz++;

pRow = (DatabaseRowEx *)realloc(pRow, sizeof(DatabaseRowEx) + 
		sizeof(DatabaseField) * nColumns * rowz); 
	wprintf(L"Row 2: ");
	for(x = 0; x < nColumns; x++)
	{
		pRow[1].pColumns[x] = (DatabaseField *)malloc(sizeof(wchar_t *) * 
			wcslen(row2elems[x]) + 1);
		wcscpy((wchar_t *)pRow[1].pColumns[x], row2elems[x]);
		wprintf(L" [ %s ] ", pRow[1].pColumns[x]);
	}
	wprintf(L"\r\n");

#include <vector>
#include <string>

class text_table:
	public std::vector<std::vector<std::wstring > >
{
	typedef std::vector<std::vector<std::wstring > > super;
public:
	typedef std::wstring string_t;
	
	void resize(size_t rows, size_t colums)
	{
		super::resize(rows);
		for(size_t i=0; i<rows; ++i)
			super::at(i).resize(cols);
	}
	
	const string_t& at(size_t rew, size_t col) const
	{ return super::at(row).at(col); }

	string_t& at(size_t rew, size_t col)
	{ return super::at(row).at(col); }
	
};

#include <memory>
#include "texttable.h"

std::auto_ptr<text_table> create_table( ... )
{
	std::auto_ptr<text_table> p(new text_table);
	p->resize(...);
	.... //add content initialization stuff
	.... //here, to fill-uip table cell texts
	
	return p;
}

2 bugs found.
> recompile ...
65534 bugs found.

modified on Tuesday, February 1, 2011 2:58 AM