[C++] Mappa e pointer of pointer

[shodan]

In senso inverso. Prima si libera il puntatore, poi il puntatore a puntatore.
Il discorso "smartpointer di smartpointer" non ha senso. E come dire: una porta che chiude una porta.
Se fai fatica a comprendere gli smart pointer, rifletti sulla classe string e wstring. Se ci pensi bene anche loro sono smart pointer di un dato char* sottostante, eppure le usi senza preoccuparti di come è gestita la memoria di quel char*.
Lo smart pointer (a semantica condivisa) si comporta allo stesso modo: gli si affida la memoria senza preoccuparsi di come e quando è liberata.
Ho riscritto il tuo esempio usando gli shared_ptr (che saranno inclusi nel prossimo standard, ma di cui molti compilatori hanno l'impementazione anche adesso. L'unica differenza è nel namespace che qui ho trascurato, ma è ininfluente ai fini del discorso).

#include "stdafx.h"
#include "A.h"
#include "B.h"
#include <string>
#include <header_shared_ptr>
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
	shared_ptr<CA> c(new CA());
	c->processA();
	shared_ptr<CB> data = c->GetCB();
	shared_ptr<CC> cx = data->m_mappa[0];
	
	wstring str = cx->GetName();
	cx = data->m_mappa[1];
	str = cx->GetName();
	return 0;
}

#pragma once
#include "B.h"
class CA
{
public:
	CA(void);
	~CA(void);
	void processA();
	shared_ptr<CB> GetCB();
private:
	shared_ptr<CB> m_b;
};

#include "StdAfx.h"
#include ".\a.h"

CA::CA(void)
{
}

CA::~CA(void)
{
}

void CA::processA()
{
	shared_ptr<CC> c(new CC());
	shared_ptr<CC> cx(new CC());
	c->SetName(L"giugio");
	cx->SetName(L"pippo");
	m_b.reset(new CB());
	m_b->processaB(c);
	m_b->processaB(cx);
}

shared_ptr<CB> CA::GetCB()
{
	return m_b;
}

#pragma once
#include "C.h"
#include <map>

using namespace std;

class CB
{
public:
	CB(void);
	~CB(void);
	void processaB(const shared_ptr<CC>& pPointer);
	map<int, shared_ptr<CC> >m_mappa;
};

#include "StdAfx.h"
#include ".\b.h"

CB::CB(void)
{
}

CB::~CB(void)
{
}

void CB::processaB(const shared_ptr<CC>& pC)
{
	m_mappa[m_mappa.size()] = pC;
	
}

#pragma once
#include <string>

using namespace std;
class CC
{
public:
	CC(void);
	~CC(void);
	void SetName(const wstring& str);
	wstring GetName() const;
private:
	wstring m_name;
};

#include "StdAfx.h"
#include ".\c.h"

CC::CC(void)
{
}

CC::~CC(void)
{
}

wstring CC::GetName() const
{
	return m_name;
}

void CC::SetName(const wstring& str)
{
	m_name = str;
}