C / C++ / MFC

nadiric wrote:

child *child1 = new child; //creating a child somewhere in code

parent1.addchild(child1); //adding the child to a parent (the code in question)

class Child
{
public:
	Child() : m_Data(0)
	{
	}
	
	// whatever other methods you want here
private:
	int m_Data;	// could be anything
};

// deque version
class Parent
{
public:
	Parent()
	{
	}

	void addChild(Child* pChild)
	{
		m_Children.push_back(pChild);
	}
private:
	std::deque<Child*> m_Children;
};

// vector version
const unsigned long DEFAULT_SIZE = 100;	// whatever a good default size for your application is
class Parent
{
public:
	Parent()
	{
		m_Children.reserve(DEFAULT_SIZE);
	}

	void addChild(Child* pChild)
	{
		m_Children.push_back(pChild);
	}
private:
	std::vector<Child*> m_Children;
};

waldermort wrote:

hey thats a great idea, I will declare all of the class functions as private, that will stop those hackers from subclassing my class. One small drawback though, it won't work.

class Base {
public:
   void doSomething() { // public non-virtual
      checkVar();
      doSomethingImp();
   }
private:
   virtual void doSomethingImp() {
   // ...
   }
};

class Derived : public Base {
public:

private:
   virtual void doSomethingImp() {
   // overrides Base::doSomethingImp()
   }
}

// in the header file
class _MyClass;
class MyClass
{
public:
	MyClass();
	~MyClass();	// declare as virutal if you want this to be able to be derived from
	void someFunc();
	// whatever other functions you want
private:
	_MyClass* m_pImpl;
};

// in the implementation
class _MyClass
{
public:
	_MyClass()
	{
	}

	void someFunc()
	{
		// do whatever
	}
};

MyClass::MyClass() : m_pImpl(new _MyClass)
{
}

MyClass::~MyClass()
{
	delete m_pImpl;
}

void MyClass::someFunc()
{
	m_pImpl->someFunc();	
}

_tprintf(tmp, _T("_%03d"), i);

TCHAR tmp[10];
memset(tmp,0,10);
if (i < 10)
    _tprintf(tmp,_T("_%03d"),i);

wprintf(tmp,L"Hello");

_stprintf(tmp,_T("_00%i"),i);

si_69 wrote:

can anyone see whats wrong ??