probleme à l'execution

#include "NuageDePoints.h"
// on cree un certain nombre de points ayant des valeurs sans importances
NuageDePoints :: NuageDePoints(int nbre){
	m_nbre = nbre;
	int i = 0;
	bool identique = false;
        // un nuage de point étant un tableau de points
	m_tab = new Point[nbre];
	if ( nbre > 0){
// pour prendre des nombres au hasard...
		m_tab[0] =  Point((int)getRand(),(int)getRand());
	} else {
		cout << "le nombre est < 1" << endl;
	}
	if (nbre > 1){
		while (i!=nbre-1){
			m_tab[i] = Point((int)getRand(),(int)getRand());
			i++;
			while(!identique){
				m_tab = pointIdentique(nbre, m_tab);
				identique = 1;
			}
		}
	}
}

NuageDePoints :: NuageDePoints(Point* tab,int nbre){
	m_tab = tab;
	m_nbre = nbre;
}

Point* NuageDePoints :: pointIdentique(int nbre, Point* tab){
	m_tab = tab;
	m_nbre = nbre;
	int i; int j;
	for(i=0;i<nbre-1;i++){
		for(j=0;j<nbre-1;j++){
			if(j!=i){
				while(tab[i].getX() == tab[j].getX() && tab[i].getY() == tab[j].getY()){
					m_tab[i].setX(getRand());
					cout << getRand()<<endl;
					m_tab[i].setY(getRand());
				}
			}
		}
	}
	return m_tab;
}

// la ca bug ....
NuageDePoints NuageDePoints :: operator+(Point a){
	
	int x = getNbre();
	Point* tab = new Point[x+1];
	for(int i =0; i<x; i ++){
		tab[i].setX(getTab()[i].getX());
		tab[i].setY(getTab()[i].getY());
	}
	tab[x].setX(a.getX());
	tab[x].setY(a.getY());
	NuageDePoints np = NuageDePoints(tab,m_nbre+1);
	return np;
}

// et le main ...
#include "Point.h"
#include "NuageDePoints.h"

int main(){
	
	Point p = Point();
	Point p2 = Point(3,5);
	Point p3 = Point(&p2);
	NuageDePoints n = NuageDePoints(2);

	Point* tab = new Point[10];
	NuageDePoints n2 = NuageDePoints(tab,2);
        //je test mon operator+
        n = n2 + p2
	n2.affiche();
	system("pause");
	return 0;
}

NuageDePoints NuageDePoints :: operator+(Point a){

NuageDePoints NuageDePoints :: operator+(const Point &a){

int x = np2.getNbre();
	Point* tab = np2.getTab();
	NuageDePoints np = NuageDePoints(tab,x+1);
	tab[x] = p1;
	np.setTab(tab);
	return np;