Salve sono nuova del forum! Spero che qualcuno mi possa dare una mano perchè sono abbastanza disperata!
ho fatto un programma in c++ abbastanza impegnativo per implementare un algoritmo complesso. Premetto che non avevo mai usato c++ e quindi non sono programmatrice esperta, il mio problema è che quando provo ad eseguire il mio programma senza il debug ad un certo punto genera eccezione e si ferma. mandandolo in esecuzione col debbunging invece tutti i metodi calcolano ciò che voglio e tira fuori la soluzione. Io penso (umilmente) che ci sia un problema su come alloco la memoria. Se ci fosse un'anima pia che intanto mi controlla se in questa classe ho fatto errori di questo tipo ne sarò immensamente grata!

codice:
matrice.h
#include <fstream>
#include <string>
#include <cmath> 
#include <iostream>
#include "stdio.h"

#ifndef MATRICE_H
#define MATRICE_H

using namespace std;

class matrice {
public:
int numRighe;
int numColonne;
double **p; //puntatore ad un array di puntatori
public:
matrice ();
matrice (int nr, int nc);
matrice(const matrice&m);
matrice(double* colonna);
~matrice ();
void inserisci();
double UnicoElemento();
matrice* preleva(int indice);
void CalcolaKernel();
matrice* Trasposta();
matrice* Moltiplica(matrice &m);
matrice* MoltiplicaperScalare(double sca);
matrice* Somma(matrice &m);
matrice* Sottrai(matrice &m);
matrice* Metodocplex(int m);
void stampa();
void Cambia(matrice m);
};
#endif
codice:
#include "matrice.h"
#include <fstream>
#include <string>
#include <cmath> 
#include <iostream>
#include <ilcplex/ilocplex.h>

using namespace std;

extern ofstream file;

//costruttore 
matrice::matrice(){
numRighe=0;
numColonne=0;
p=0;
}

//costruttore con dimensioni
matrice::matrice(int nr, int nc){
numRighe=nr;
numColonne=nc;
p = new double*[numColonne]; //array di puntatori
for (int i=0; i<numColonne; i++)
p[i]= new double [numRighe]; //array di valori
}

//costruttore di copia
matrice::matrice(const matrice &m){
numRighe=m.numRighe;
numColonne=m.numColonne;
p = new double*[m.numColonne]; 
for (int k=0; k<m.numColonne; k++){
	p[k]= new double [m.numRighe];} 
for(int i=0; i<m.numColonne ; i++){
	for(int j=0; j<m.numRighe ; j++){
		p[i][j]= m.p[i][j];
 }}}

//costruttore di una matrice-vettore a partire da un array di double
matrice::matrice(double* colonna){
numRighe=3;//sizeof(colonna[0])/sizeof(colonna);
numColonne=1;
p = new double*[numColonne]; //array di puntatori
for (int i=0; i<numColonne; i++)
p[i]= new double [numRighe]; //array di valori
for(int k=0; k<numColonne ; k++){
p[k]= colonna;
}}

//distruttore
matrice::~matrice(){
file << "Distruzione della matrice..." << endl;
for (int i=0; i<numColonne; i++)
delete [] p[i];
delete [] p;
}

//inserisce valori degli elementi da file
void matrice::inserisci(){
	string stringa;
	int i,j;
	double n;
ifstream input("prova.txt");
    if(!input.good())
       file << "errore nella lettura del file." << endl;
    while(!input.eof()){
        input >> stringa >> i >> j >> n;
        p[i-1][j-1]= n;}
    input.close();
}

//se la matrice è una matrice 1x1 ne restituisce il valore come double
double matrice::UnicoElemento(){
	if(this->numColonne==1 && this->numRighe==1){
	double elem;
	elem=p[0][0];
	return elem; }
	else { 
		file<<"l'elemento non è unico"<<endl;
		return 0;
	}}

//indicando l'indice, restituisce una colonna della matrice sottoforma di matrice-vettore 
matrice* matrice::preleva(int indice_colonna){
    matrice *col= new matrice(p[indice_colonna]);
	return col;
}
    
//calcola il kernel RBF, fa quindi side effect sulla matrice
void matrice::CalcolaKernel(){
	double sigma;
	file << "Inserire il valore di sigma:";
	cin >> sigma;
	for (int i=0; i<numColonne; i++){
		for (int j=0; j<numRighe; j++){
          p[i][j] = pow(2.72,-(pow(p[i][j],2.0))/sigma);
		}
	}
}

// alloca dinamicamente la matrice trasposta rispetto a quella di invocazione e viene restituito il puntatore a tale matrice allocata
matrice* matrice::Trasposta(){
	matrice *r=new matrice(numColonne,numRighe);
	for(int i=0; i<this->numRighe; i++){
		for(int j=0; j<this->numColonne; j++){
			r->p[i][j]= p[j][i];}
	                                       }
	return r;}

//alloca dinamicamente la matrice che è il prodotto fra la matrice di invocazione e la matrice passata come parametro e ne restituisce il puntatore
matrice* matrice::Moltiplica(matrice &m){
	if(numColonne!=m.numRighe){
		file<<"non è possibile effetturare il prodotto";
			file<<endl;}
        matrice *r=new matrice(this->numRighe,m.numColonne);
		for(int i=0; i<m.numRighe; i++){
			for(int j=0; j<m.numColonne; j++){
				r->p[j][i]=0;
				for(int k=0; k<numColonne; k++){
				r->p[j][i]+=p[k][i]*m.p[j][k];}
		}
		}
	        return r;}

//alloca dinamicamente la matrice che è il prodotto fra la matrice di invocazione e uno scalare e ne restituisce il puntatore
matrice* matrice::MoltiplicaperScalare(double sca){
	matrice *r=new matrice(this->numRighe,this->numColonne);
		for(int i=0; i<numColonne; i++){
			for(int j=0; j<numRighe; j++){
				r->p[i][j]=this->p[i][j]*sca;
			    }}
		return r;}

//alloca dinamicamente la matrice che è la somma fra la matrice di invocazione e la matrice passata come argomento, restituendo il puntatore
matrice* matrice::Somma(matrice &m){
	if(this->numColonne!=m.numColonne || this->numRighe!=m.numRighe){
		file<<"non è possibile effetturare la somma";
			file<<endl;
	return 0;}
	else{
	matrice *r= new matrice(this->numRighe,this->numColonne);
	for (int i=0; i<numColonne; i++){
	for(int j=0; j<numRighe; j++){
    r->p[i][j]= p[i][j]+m.p[i][j];
	}}
	return r;}
	}	

//alloca dinamicamente la matrice che la differenza fra la matrice di invocazione e la matrice passata come argomento e restituisce il puntatore
matrice* matrice::Sottrai(matrice &m){
	if(numColonne!=m.numColonne || numRighe!=m.numRighe){
		file<<"non è possibile effetturare la differenza";
			file<<endl;}
    matrice *r= new matrice(this->numRighe,this->numColonne);
	for (int i=0; i<numColonne; i++){
	for(int j=0; j<numRighe; j++){
    r->p[i][j]= p[i][j]-m.p[i][j];
	}}
	return r;
	}

//usando i dati relativi alla matrice costruisce e risolve un problema di programmazione lineare restituendo il puntatore alla matrice-vettore delle soluzioni(lambda) 

matrice* matrice::Metodocplex(int numero){
file<<"Metodo cplex"<<endl;
matrice* lambda=new matrice(numero,1);
matrice b=matrice(numero,1);
matrice A=matrice(numero,numero);
for(int j=0; j<numero; j++){
 for(int i=0; i<numero; i++){
        A.p[j][i]=(this->preleva(i)->Trasposta())->Moltiplica(*this->preleva(j))->UnicoElemento();
	
matrice *Ab;
Ab = A.MoltiplicaperScalare(2);

IloEnv env;
      try {
      IloModel model(env);
      int k;  
      IloNumVarArray vars(env);
	  k=0;
	  while(k<numero){
	  vars.add(IloNumVar(env, -IloInfinity, IloInfinity));//aggiunge la variabile 
	  k=k+1;}   
      for(int i=0; i<numero; i++){
		  IloExpr expr(env);
	  for(int j=0; j<numero; j++){
		  expr += Ab->p[j][i] * vars[j];}
		  
	   model.add(b.p[0][i]<= expr <= b.p[0][i]);
	   expr.end();
	  }

	   IloCplex cplex(model);
      if ( !cplex.solve() ) {
         env.error() << "Failed to optimize LP." << endl;
         throw(-1);
	  }      
     IloNumArray vals(env);
      cplex.getValues(vals, vars);
      env.out() << "Values = " << vals << endl;
	  for(int h=0; h<numero; h++){
		  lambda->p[0][h]=vals[h];} 
	  
	}
   catch (IloException& e) {
      cerr << "Concert exception caught: " << e << endl;
   }  
   catch (...) {
      cerr << "Unknown exception caught" << endl;
   }   
   env.end();  
  return lambda;
  }

//stampa della matrice
void matrice::stampa(){
for (int i=0; i<numRighe; i++)
{
for (int j=0; j<numColonne; j++)
file << p[j][i] << " ";
file << endl;}
}
void matrice::Cambia(matrice m){
for(int i=0; i<numColonne ; i++){
	for(int j=0; j<numRighe ; j++){
		p[i][j]= m.p[i][j];
    
	}}
}