[C++] Segmentation fault durante un'allocazione statica

[RooccoXXI]

Ciao a tutti.
In questo semplice programma ottengo un segmentation fault (11) quando viene allocato l'oggetto della classe Molla:

#include "Gravita.h"
#include "IntegratoreEulero.h"
#include "Molla.h"

#include <iostream>
using std::cout;
using std::endl;

int main()
{
	Gravita g({0,0,-9.81}, 0);
	
	cout << "Campo di gravita:" << endl;
	cout << g << endl;
	
	Molla M({0.4},{0},0.1,0.1,{0,0,0},{0,0,1},{0,1,-1},1.38165,0.01);
	g.agisci_su(M);
	
	cout << "\nMolla:" << endl;
	cout << M << endl;
	
	return 0;
}

Mi sono scervellato un po' ma proprio non capisco da dove possa venire. Il problema però é in quella classe perché le altre le ho testate tutte piuttosto a fondo e hanno sempre funzionato... Allego quindi la definizione di tale classe:

#ifndef MOLLA_H
#define MOLLA_H

#include "OggettoMobile.h"

class Molla : public OggettoMobile
{
public:
	// --- COSTRUTTORI ---
	Molla(const Vettore&, const Vettore&, double, double, const Vettore&, const Vettore&, const Vettore&, double, double = 0, double = 1, double = 1);
	Molla(const vector&, const vector&, double, double, const vector&, const vector&, const vector&, double, double = 0, double = 1, double = 1);
	Molla(const list&, const list&, double, double, const list&, const list&, const list&, double, double = 0, double = 1, double = 1);
	
	// --- METODI ---
	Vettore evoluzione() const;
	
	void stampa(std::ostream&) const;
	
	Vettore get_posizione() const;
	Vettore get_velocita() const;

protected:
	// --- ATTRIBUTI ---
	Vettore origine;
	Vettore direzione;
	double k;
	double b;
	
private:
	// --- METODI ---
	Vettore unitario(const Vettore&) const;
	Vettore unitario(const vector) const;
	Vettore unitario(const list) const;
};

#endif

#include "Molla.h"

// *** PUBLIC ***

// --- COSTRUTTORI ---

Molla::Molla(const Vettore& p, const Vettore& v, double r, double m, const Vettore& f, const Vettore& O, const Vettore& d, double k, double b, double a, double mu)
: OggettoMobile(p,v,r,m,f,a,mu), origine(O), direzione(unitario(d)), k(k), b(b)
{}

Molla::Molla(const vector& p, const vector& v, double r, double m, const vector& f, const vector& O, const vector& d, double k, double b, double a, double mu)
: OggettoMobile(p,v,r,m,f,a,mu), origine(O), direzione(unitario(d)), k(k), b(b)
{}

Molla::Molla(const list& p, const list& v, double r, double m, const list& f, const list& O, const list& d, double k, double b, double a, double mu)
: OggettoMobile(p,v,r,m,f,a,mu), origine(O), direzione(unitario(d)), k(k), b(b)
{}

Vettore Molla::evoluzione() const
{
	Vettore r( (1 / massa) * (forza * direzione - k * omega[0] - b * omega_[0]) );

	return r;
}

void Molla::stampa(std::ostream& out) const
{
	OggettoMobile::stampa(out);
	out << direzione << " # direzione" << std::endl;
	out << k << " # k" << std::endl;
	out << b << " # b" << std::endl;
}

Vettore Molla::get_posizione() const
{
	return origine + omega[0] * direzione;
}

Vettore Molla::get_velocita() const
{
	return omega_[0] * direzione;
}

// *** PRIVATE ***

// --- METODI ---

Vettore Molla::unitario(const Vettore& V) const
{
	return (1 / V.norma()) * V;
}

Vettore Molla::unitario(const vector V) const
{
	Vettore r(unitario(V));

	return std::move(r);
}

Vettore Molla::unitario(const list V) const
{
	Vettore r(unitario(V));

	return std::move(r);
}

Grazie,
R.

[shodan]

Non ci metto la mano sul fuoco, ma questi due costruttori mi paiono dubbi:

Molla(const Vettore&, const Vettore&, double, double, const Vettore&, const Vettore&, const Vettore&, double, double = 0, double = 1, double = 1);

Molla(const vector&, const vector&, double, double, const vector&, const vector&, const vector&, double, double = 0, double = 1, double = 1);

Se non ricordo male Vettore può acquisire dati da una initialization_list, ma può farlo anche std::vector. La domanda è: se costruisci un oggetto Molla tramite initialization_list, quale dei due costruttori è invocato?

[RooccoXXI]

Originariamente inviato da shodan
Non ci metto la mano sul fuoco, ma questi due costruttori mi paiono dubbi:

Molla(const Vettore&, const Vettore&, double, double, const Vettore&, const Vettore&, const Vettore&, double, double = 0, double = 1, double = 1);

Molla(const vector&, const vector&, double, double, const vector&, const vector&, const vector&, double, double = 0, double = 1, double = 1);

Se non ricordo male Vettore può acquisire dati da una initialization_list, ma può farlo anche std::vector. La domanda è: se costruisci un oggetto Molla tramite initialization_list, quale dei due costruttori è invocato?

Scusa, non ho dato il quadro completo: list é un typedef per std::initializer_list<double>, quindi é il terzo costruttore ad essere chiamato.

Questo pomeriggio ho speso ancora molto tempo a guardare ma proprio non ho trovato il problema...

[shodan]

Prova a fare un passaggio senza const reference di quella list o indagare sul costruttore di OggettoMobile. Non è che si possa dire molto altro senza compilare il codice.

[RooccoXXI]

Originariamente inviato da shodan
Prova a fare un passaggio senza const reference di quella list o indagare sul costruttore di OggettoMobile. Non è che si possa dire molto altro senza compilare il codice.

Il codice compila perfettamente. L'errore si produce proprio solo in esecuzione. Gli stessi identici costruttori funzionano per la classe Palla, per la classe Oggetto e quasi tutte le altre classi del progetto (prevedo sempre un costruttore per Vettore, uno per std::vector e uno per std::initializer_list). Ho scritto questa classe come le altre... Se vuoi allego tutto il progetto!

[shodan]

Non compilerebbe a me (VC++2010 non supporta l'initializer_list).
Hai provato se un solo un oggetto Molla ti da il problema?

int main()
{
	Molla M({0.4},{0},0.1,0.1,{0,0,0},{0,0,1},{0,1,-1},1.38165,0.01);
}

Al limite metti il progetto in un file storage e passa il link.

[RooccoXXI]

Originariamente inviato da shodan
Non compilerebbe a me (VC++2010 non supporta l'initializer_list).
Hai provato se un solo un oggetto Molla ti da il problema?

int main()
{
	Molla M({0.4},{0},0.1,0.1,{0,0,0},{0,0,1},{0,1,-1},1.38165,0.01);
}

Al limite metti il progetto in un file storage e passa il link.

Sempre segmentation fault...

I sorgenti (senza .o ed eseguibili) li puoi trovare qui (zippati):

https://www.dropbox.com/s/5c0glozgt2...imulazione.zip

Grazie mille per la disponibilità!

[shodan]

Controlla per bene questa funzione:

Vettore Molla::unitario(const list V) const
{
	Vettore r(
            unitario(V)  // in particolare questa chiamata.
        ); 

	return std::move(r);
}

[RooccoXXI]

Originariamente inviato da shodan
Controlla per bene questa funzione:

Vettore Molla::unitario(const list V) const
{
	Vettore r(
            unitario(V)  // in particolare questa chiamata.
        ); 

	return std::move(r);
}

Che scemo! chiamata ricorsiva infinita? Volevo utilizzare sempre una sola funzione di base, utilizzata poi dalle altre, ma sono stato frettoloso e non ho riflettuto... =S.

Modificato come segue (poi metterò anche in pratica il tuo consiglio di passare per valore, risparmiando così una linea di codice).

Vettore Molla::unitario(const Vettore& V) const
{
	return (1 / V.norma()) * V;
}

Vettore Molla::unitario(const vector& V) const
{
	Vettore r(V);

	return std::move(unitario(r));
}

Vettore Molla::unitario(const list& V) const
{
	Vettore r(V);

	return std::move(unitario(r));
}

Grazie mille, ora funziona.

[shodan]

Nota. Se al posto di passare Valore per const reference, lo passi per valore.

Vettore Molla::unitario(Vettore V) const
{
	return (1 / V.norma()) * V;
}

e le altre chiamate le fai così:

    return std::move(unitario ( Vettore(V) ) );

hai solo temporanei, quindi move semantics a go go.