[C++] assurdità

[71104]

qualcuno mi saprebbe spiegare per quale assurdo motivo lo standard del C++ non ammette i tipi a virgola mobile come template parameters?

è una cosa completamente senza senso, del tutto immotivata: si tratta di una feature implementabilissima, tant'è che la Microsoft per aderire allo standard l'ha dovuta togliere da Visual C++ .NET, creando tra l'altro un breaking change.

Strùtrup è un c******e -.-'

[marko.fatto]

fìììco

[^TiGeRShArK^]

W il C++

[^TiGeRShArK^]

Originariamente inviato da marko.fatto

fìììco

OT
ma non ti conveniva usare la tavolozza di colori ottimizzata piuttosto che il dithering nell'avatar?

[marko.fatto]

Originariamente inviato da ^TiGeRShArK^

OT
ma non ti conveniva usare la tavolozza di colori ottimizzata piuttosto che il dithering nell'avatar?

mi sforava sempre nel peso

[marko.fatto]

scusate ma nell'esempio che c'è qui
questo pezzo:

 // allocate memory:
  buffer = new char [length];

non dovrebbe essere:

 // allocate memory:
  buffer = new char [length+1];

per mettere anche il carattere di terminazione?

[DanieleC88]

Originariamente inviato da marko.fatto

non dovrebbe essere:

 // allocate memory:
  buffer = new char [length+1];

per mettere anche il carattere di terminazione?

No:

cout.write (buffer,length);

[marco.r]

Originariamente inviato da 71104

qualcuno mi saprebbe spiegare per quale assurdo motivo lo standard del C++ non ammette i tipi a virgola mobile come template parameters?

è una cosa completamente senza senso, del tutto immotivata: si tratta di una feature implementabilissima, tant'è che la Microsoft per aderire allo standard l'ha dovuta togliere da Visual C++ .NET, creando tra l'altro un breaking change.

Suppongo sia dovuto al fatto che trattare in modo preciso con i floating point e' molto difficile, per cui c'e' il rischio concreto che cambiando anche solo i flag di compilazione vengano generati istanze di template diverse (immagina di fare delle operazioni con le SSE (64bit di precisione) invece che con la FPU (80)) e con rischi di bug subdoli.
Per inciso non mi viene in mente un esempio pratico di utilizzo di floating point come parametri template. Qualche idea ?

[cdimauro]

Una lista/stack/coda/lista doppiamente concatenata/ecc. di float?

[71104]

Originariamente inviato da marco.r

Suppongo sia dovuto al fatto che trattare in modo preciso con i floating point e' molto difficile, per cui c'e' il rischio concreto che cambiando anche solo i flag di compilazione vengano generati istanze di template diverse (immagina di fare delle operazioni con le SSE (64bit di precisione) invece che con la FPU (80)) e con rischi di bug subdoli.

uhm, effettivamente questo ha senso...

Per inciso non mi viene in mente un esempio pratico di utilizzo di floating point come parametri template. Qualche idea ?

quello che stavo cercando di fare io, ovvero una classe che rappresenta una generica costante matematica, come pi greco o la e. anziché fare una classe per ogni costante volevo fare un'unica classe templatizzata più una typedef per ogni costante: ciascuna typedef veniva definita al template con la rispettiva costante come argomento.

senza poter passare i numeri a virgola mobile come template parameters invece devo fare una classe base che contiene un campo double che è il valore della costante, e poi N classi derivate ciascuna delle quali chiama il costruttore protetto nella classe base passandogli la rispettiva costante. inoltre le N classi derivate hanno anche qualche altra specializzazione, per esempio ciascuna di esse ritorna il nome della costante ("pi", "e", ecc.).

Originariamente inviato da cdimauro

Una lista/stack/coda/lista doppiamente concatenata/ecc. di float?

non c'entra, in quel caso non passi un tipo float, passi un typename cioè il nome di un tipo; che può anche essere float. in altre parole non è questo che è vietato in C++:

list<float> ListOfFloatNumbers;

bensì questo:

template<float _Value>
class Constant
{
public:
	// ...

};

...

Constant<M_PI> PI;

[DanieleC88]

Originariamente inviato da 71104

quello che stavo cercando di fare io, ovvero una classe che rappresenta una generica costante matematica, come pi greco o la e.

Uhm, non è sufficiente descriverla come const float? Fare un template apposito cosa ti farebbe guadagnare?

[ilsensine]

Originariamente inviato da marco.r

Suppongo sia dovuto al fatto che trattare in modo preciso con i floating point e' molto difficile, per cui c'e' il rischio concreto che cambiando anche solo i flag di compilazione vengano generati istanze di template diverse (immagina di fare delle operazioni con le SSE (64bit di precisione) invece che con la FPU (80)) e con rischi di bug subdoli.

Bè non credo, la precisione è un conto (e dipende dal processore), ma la dimensione è fissa per un dato compilatore. 64bit è double, 80 è long double, sulle nostre macchine.

Non capisco neanch'io questo limite però...

[71104]

Originariamente inviato da DanieleC88

Uhm, non è sufficiente descriverla come const float? Fare un template apposito cosa ti farebbe guadagnare?

non l'ho descritta come const float perché si trattava di un programma per risolvere derivate e semplificare espressioni (se guardi un certo thread di qualche giorno fa capirai ), e quindi la costante deve costituire un tipo di espressione rappresentata come classe che risponda ad una certa interfaccia; nello specifico doveva avere un metodo Derive che calcola la derivata (cioè 0) e un metodo Simplify che resituisce this, più un po' di altra roba.

ne volevo fare un template perché così non dovevo scrivere una classe per ogni costante matematica usata.

[71104]

Originariamente inviato da ilsensine

Non capisco neanch'io questo limite però...

io ho interpretato il discorso di marco.r in questa maniera; metti che uno scrive una cosa del genere:

template<float _Value>
class Floated
{
	// ...
};

Floated<1> First;
Floated<1.0> Second;
Floated<2-1> Third;
...

non lo so mica se il compilatore genera sempre la stessa definizione... e in effetti non è comunque una buona abitudine per lo stesso motivo per il quale i confronti tra numeri a virgola mobile vanno evitati o fatti con un delta.

[DanieleC88]

Ah ok, non avevo capito quale fosse il tuo scopo. Be', in questo caso mi sembra più che giusto. Non avendo la possibilità di usare template, puoi pensare di salvare separatamente queste costanti? Così poi le tratti nei casi particolari quando derivi la formula o la semplifichi.

[71104]

Originariamente inviato da DanieleC88

Ah ok, non avevo capito quale fosse il tuo scopo. Be', in questo caso mi sembra più che giusto. Non avendo la possibilità di usare template, puoi pensare di salvare separatamente queste costanti? Così poi le tratti nei casi particolari quando derivi la formula o la semplifichi.

alla fine ho fatto una cosa del genere:

class Expression
{
public:
	virtual operator string () const = 0;
	virtual Expression *Derive() = 0;
	virtual Expression *Simplify() = 0;

};

class Constant : public Expression
{
public:
	Expression *Derive();
	Expression *Simplify();

};

class PI : public Constant
{
public:
	operator string () const;

};

class E : public Constant
{
public:
	operator string () const;

};

Expression *Constant::Derive()
{
	// ritorna un'espressione che vale costantemente 0
}

Expression *Constant::Simplify()
{
	return this;
}

PI::operator string () const
{
	return "pi";
}

E::operator string () const
{
	return "e";
}

(non è proprio questo il codice, semplifico)

mentre invece avrei voluto fare:

template<double _Value, const char *_Name>
class Constant : public Expression
{
public:
	operator string () const
	{
		return _Name;
	}

	Expression *Derive()
	{
		// ritorna un'espressione che vale costantemente 0
	}

	Expression *Simplify()
	{
		return this;
	}

};

typedef Constant<M_PI, "pi"> PI;
typedef Constant<M_E, "e"> E;

[ilsensine]

Originariamente inviato da 71104

io ho interpretato il discorso di marco.r in questa maniera; metti che uno scrive una cosa del genere:

template<float _Value>
class Floated
{
	// ...
};

Floated<1> First;
Floated<1.0> Second;
Floated<2-1> Third;
...

non lo so mica se il compilatore genera sempre la stessa definizione... e in effetti non è comunque una buona abitudine per lo stesso motivo per il quale i confronti tra numeri a virgola mobile vanno evitati o fatti con un delta.

No continuo a non vedere perché un float qui possa dare problemi.

Allora anche questo non va bene:

template<char _param>
class MrX [...]

in quanto può generare cose diverse a seconda dell'architettura e (sotto il gcc almeno) dei parametri di compilazione.

[71104]

Originariamente inviato da ilsensine

No continuo a non vedere perché un float qui possa dare problemi.

Allora anche questo non va bene:

template<char _param>
class MrX [...]

in quanto può generare cose diverse a seconda dell'architettura e (sotto il gcc almeno) dei parametri di compilazione.

che generi cose diverse a seconda dell'architettura va benissimo: chi se ne frega
mai sentito parlare di ABI mismatch?

[DanieleC88]

Originariamente inviato da 71104

alla fine ho fatto una cosa del genere: [...]

Ottima soluzione, in effetti... dovrei esercitarmi di più con la OOP...

Certo era più comodo (ed "elegante") con un template, ma finché funziona...

[ilsensine]

Originariamente inviato da 71104

che generi cose diverse a seconda dell'architettura va benissimo: chi se ne frega

Eh peccato che puoi decidere con un flag di compilazione se char debba essere signed o unsigned...e una volta mi è servito...