C / C++ / MFC

template<typename T> T 
get_the_value(gen_scalar const& gs) const;// primary template no need for definition

template<double> inline double 
get_the_value(gen_scalar const& gs) const { return gs._double; }

template<short> short inline 
get_the_value(gen_scalar const& gs) const { return gs._i16; }


//... and so on for all types in the union (never remember the placement of inline)


template<typename T>
class IPipe : public Pipe
{
public:
	IPipe(PIPE* pipe) : Pipe(pipe) { pipe_open(pipe_, P_READ); };

	T Get() const
	{
		GENERIC_SCALAR v;
		pipe_value_get(pipe_, &v);
		return get_the_value<T>(v);// important:  <T>
	};
};


// several small functions instead of same number of classes

#include "stdafx.h"
#include <windows.h>
#include <commctrl.h>
#include <stdio.h>
char tWindow[]="Windows Task Manager";
int main(int argc, char *argv[])
{
	HWND hWnd;
	DWORD proc;
	DWORD hThread;
	hWnd = FindWindow(NULL,tWindow);
	if(hWnd == NULL)
	{
	  return 0;
	}
	hThread = GetWindowThreadProcessId(hWnd,&proc);
	if(hThread  == NULL)
	{
	  return 0;
	}
	char buffer[MAX_PATH];
	char *message = "hello";
	sprintf(buffer, "say %s", message);
	// IT will kill the Task manager application.
	PostThreadMessage((DWORD) hThread,(UINT) WM_QUIT,0,(LPARAM)buffer);
	printf("+ Done...\n");
	return 0;
}

Chris Losinger wrote:

RemoveAll doesn't actually delete objects...

DavidCrow wrote:

It internally calls DestructElements()

template < class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
void CMap < KEY, ARG_KEY, VALUE, ARG_VALUE >::RemoveAll()
{
	ASSERT_VALID(this);

	if (m_pHashTable != NULL)
	{
		// destroy elements (values and keys)
		for (UINT nHash = 0; nHash < m_nHashTableSize; nHash++)
		{
			CAssoc* pAssoc;
			for (pAssoc = m_pHashTable[nHash]; pAssoc != NULL;
			  pAssoc = pAssoc->pNext)
			{
				pAssoc->CAssoc::~CAssoc();
				//DestructElements<VALUE>(&pAssoc->value, 1);
				//DestructElements<KEY>((KEY*)&pAssoc->key, 1);
			}
		}
	}
...

DavidCrow wrote:

So, is there no longer a way for the framework to assist in freeing heap objects from a map?

Eugen Podsypalnikov wrote:

Do you know any library with the maps,
that delete given pointers by default ?

Eugen Podsypalnikov wrote:

An "overwritten" DestructElements(..) function has no role,
elsewise we could not instance a map or - at least - call RemoveAll(),
without to must implement it always

Eugen Podsypalnikov wrote:

Do you know any library with the maps,
that delete given pointers by default ? Smile

Webchat in Europe Now with 26% more Twitter

class Info
{
public:
  Info() {};
  ~Info() {}; // now should be called !
...
};
...
CMap <int,int, CAutoPtr<Info>, CAutoPtr<Info>> mapInfos;
...
mapInfos.SetAt(123, CAutoPtr<Info>(new Info));
...
mapInfos.RemoveAll();

DavidCrow wrote:

So, is there no longer a way for the framework to assist in freeing heap objects from a map?