Newsgroup: it.comp.lang.c++
Titolo: Chiamare costruttore da funzione template

Salve,
ho il seguente codice:
#include <iostream>
#include <vector>
class A {
 public :
  A() {std::cout << "Ctor " << this << std::endl;};
  A(const A& r) {std::cout << "Copy Ctor " << this << " &r = " << &r <<
std::endl;};
  ~A() {std::cout << "Dtor " << this << std::endl;};
};
template <class T>
 void f() {
  T();
};
int main() {
 f<A>();
 return 0;
}
Se in f volessi invocare il costruttore di copia di A che sintassi dovrei
usare?
Grazie

 usare?
T(T()); ?
--  
int

"int i=0 0" <'@.'> ha scritto nel messaggio
news:ayCVd.1833$WC1...@tornado.fastwebnet.it...

No, gia provato e non va.

 No, gia provato e non va.
Aggiungo che quell'istruzione mi sa che viene intepretata come:
T T();
Infatti se provo:
A a;
T(a);
Mi dice che a e' gia stato dichiarato come A. Evidentemente T(a) viene
considerato T a.
Ciao

Hai provato T((T())) ?
Ciao,
Nicola

{ T t; T u(t); }
Visto che il costruttore di copia vuole gią un'istanza, devi comunque
prima crearla.
Perņ certo che T( T() ) venga interpretato T T() č strano.
PS: Se usi g++, usa __PRETTY_FUNCTION__
#include<iostream>
using namespace std;
struct A {
    A()
    { cout << __PRETTY_FUNCTION__ << endl; }
    A(const A& a)
    { cout << __PRETTY_FUNCTION__ << endl; }
};
template<class T>
void f() { T t; T u(t); }
int main()
{
    f<A>();
}
A::A()
A::A(const A&)
-- 
int

 usare?
T t1;
T t2( t1 );
EMG
--
EMAG Software Homepage:     
http://www.emagsoftware.it
The EMG's ZX-Spectrum Page: 
http://www.emagsoftware.it/spectrum
The Best of Spectrum Games: 
http://www.emagsoftware.it/tbosg

"int i=0 0" <'@.'> ha scritto:
{ T t; T u(t); }
Incredibile, e' stata la cosa piu ovvia a cui ho pensato dopo aver visto che
T(T()) non funzionava e nemmeno in quel modo funzionava tanto che ho postato
il sorgente, ma adesso ho provato e compila :/
Grazie comunque
Ciao

 Hai provato T((T())) ?
Non va.
Ciao

 T t2( t1 );
Come ho gia detto a int i = 0 0 (bel nick :P) l'avevo gia provato ma credo
di aver fatto qualche errore di sintassi che non vedevo... infatti adesso
compila ma prima no.
Invece pongo un'altro sempre relativo ai template:
#include <iostream>
#include <vector>
class A {
 public :
  A() {std::cout << "Ctor " << this << std::endl;};
  A(const A& r) {std::cout << "Copy Ctor " << this << " &r = " << &r <<
std::endl;};
  ~A() {std::cout << "Dtor " << this << std::endl;};
};
template <class T*>
 void f() {
  new T();
};
int main() {
 f<A*>(); // Non va
 return 0;
}
Con che sintassi istanzio f?
Grazie

 usare?
Il costruttore di copia funge quando crei un oggetto a partire da un altro
oggetto. Poi viene chiamato implicitamente anche in altri casi (passaggio
per copia, valore di ritorno di funzione per copia...)
Per esempio fai una g siffatta.
template<class T>
void g(T t){ };
Ma anche un
template<typename T>
void f(){
T t();
T u(t);
}
funge.
-- 
[ RiK0                                ]
[ non credo negli schemi non vincenti ]
[ two is an odd prime number          ]

 considerato T a.
Ma quello li dove lo scrivi? Perche' T non e' un tipo... e' un "segnaposto"
se all'interno di qualcosa di templatico (classe, funzione), un nonsenso
altrimenti.


 altrimenti.
Io scrivevo dentro f:
A a;
T(a);
Anche se' e' un "segnaposto" nel momento in cui la funzione viene istanziata
T viene considerato un tipo.
Ciao

 template <class T*>
template <class T>


 template <class T>
Beh si, ma visto che <class T*> compila che cosa vuol dire allora?
Ciao


A me non compila né con Microsoft Visual C++ Toolkit 2003 né con Borland
C++ 5.5.1.


 T viene considerato un tipo.
E infatti è all'interno di qualcosa di templatico ( f appunto).
Resta il fatto che se istanzi f per una classe B che non ha un
costruttore ad un argomento a partire da A, schianta. Non mi ero
spiegato benissimo.
Salvo che io non ho capito tu cosa vuoi fare.
Vuoi vedere in quali casi puoi usare la sintassi T()?
Oppure vuoi applicare un costruttore di copia?
-- 
[ RiK0                                ]
[ Go away! The internet is full!      ]
[ Non credo negli schemi non vincenti ]

 Come ho gia detto a int i = 0 0 (bel nick :P)
E` un nick che si compila!
-- 
int

 Oppure vuoi applicare un costruttore di copia?
No volevo solo sapere la sintassi da usare per invocare il costrutture di
copia.
Ciao

 E` un nick che si compila!
E come?
Spero tu non intenda:
std::cout << "int i=0 0" << std::endl; :PPP
Ciao

 E` un nick che si compila!
compilerebbe se ci fosse il punto e virgola ;-)
20:30:54 flopiano@localhost > echo "int i=0" > nick.cc
20:31:09 flopiano@localhost > g++ -c nick.cc
nick.cc:1: error: syntax error at end of input
20:31:11 flopiano@localhost > echo "int i=0;" > nick.cc
20:31:14 flopiano@localhost > g++ -c nick.cc
20:31:16 flopiano@localhost > ls
nick.cc nick.o
20:31:18 flopiano@localhost > 
:-)
Fabio

 compilerebbe se ci fosse il punto e virgola ;-)
Nemmeno. Il suo nick e' int i=0 0.
Ciao

 copia.
class Tipo{
public:
    Tipo() ;
    Tipo(const Tipo&);
}
Tipo Variabile;
Tipo AltraVariabile(Variabile);
E poi insisto... la semantica del costruttore di copia è presente anche
in altre operazioni.
void g(Tipo i);
qui per esempio
Comunque per avere un po' di esempi su costruttori di copia e
assegnamento:
#include <iostream>
struct A{
    A() { 
        std::cout << "A constructed (" << this << ")" << std::endl; 
    }
    A(const A& x) { 
        std::cout << "A copy constructed from " << &x << std::endl; 
    }
    A& operator=(const A& x) { 
        std::cout << "A assigned " << &x << std::endl; 
        return *this; 
    }
};
void g(A a) {
    std::cout << "g  with " << &a << std::endl;
}
A h() {
    std::cout << "h" << std::endl; 
    A a; 
    return a; 
};
void f(){
    std:: cout << "Default constructor" << std::endl;
    A a;
    A d;
    std:: cout << "Copy constructor" << std::endl;
    A b(a);
    A c = a;
    std:: cout << "Operator=" << std::endl;    
    d = b;
    d = c = b;
 
    std:: cout << "By value" << std::endl;
    g(b);
    std:: cout << "Return value" << std::endl;
    h();
    c = h();
 
    std:: cout << "Other" << std::endl;
    A();
}
 
int main(){
    f();
    return 0;


 T T();
Qui stai dichiarando una funzione di nome T e che ritorna un tipo T.
Vuoi un bel giochino riguardo questo?
Quello che ottieni è solo un semplice warning per il raggiungimento
della fine di una funzione non void senza dare valore di ritorno.
crazy2.cc
------------------------------
#include <iostream>
#include "crazy.hh"
A A() {
    std::cout << "funzione" << std::endl;
}
crazy.hh
-----------------------------
#include <iostream>
struct A{
    A() { std::cout << "Constructed" << std::endl; }
};
crazy.cc
-------------------------------------
#include <iostream>
#include "crazy.hh"
int main(){
    A();
    A A();
    A();
}
Compila con
gcc -pedantic -W -Wall crazy.cc crazy2.cc



Ma avere i newsreader che si mangiano il mio nick? (può essere..)
int i=0<'@.'>0;
La "at" ed il "punto" sono tra apici singoli, ovverossia un int
costruito con la sintassi di un char. Questo perché il parser del server
news si aspetta qualcosa del tipo: nome <us...@qualcosa.qualcosaltro>
dove però si può omettere qualcosa e qualcosalto, ma non la "at", il
"punto" e le parentesi angolate se si usa "nome".
Questo valore viene confrontato maggiore a zero da una parte ed il
risultato confrontato a sua volta di nuovo maggiore a zero.
Il tutto, assegnato ad int i.
$ echo "int i=0<'@.'>0;" >x.cpp
$ g++ -c x.cpp
x.cpp:1:9: warning: multi-character character constant
g++ (GCC) 3.4.4
PS: ho detto che *compila* ;-)
-- 
int

 costruito con la sintassi di un char.
E come fai a mettere 2 char tra 2 apici singoli?
Se il tuo nick e': int i=0<'@.'>0; a me non compila.
Ciao


Il mio compila davvero.
Max

 Se il tuo nick e': int i=0<'@.'>0; a me non compila.
$ cl /c nick.cpp
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.10.3077 for 80x86
Copyright (C) Microsoft Corporation 1984-2002. All rights reserved.
sign.cpp
sign.cpp(1) : warning C4804: '>' : unsafe use of type 'bool' in operation
Fino ad ora due compilatori (l'altro č g++ su linux) me l'accettano. Uno
no (quello di Noixe).
A questo punto chiedo:
    int i='ab';
č legale?
-- 
int

     int i='ab';
ma penso di no: ab non e' un carattere, e' una stringa.
Ciao


Il mio č pių breve :-P
-- 
int

 ma penso di no: ab non e' un carattere, e' una stringa.
'ab' non è un carattere, sono due caratteri, che nel mio caso formano
(almeno una parte di) un int.
'ab' non è comunque una stringa (quella con "" o std::string almeno).
-- 
int

 'ab' non è comunque una stringa (quella con "" o std::string almeno).
Si, intendevo in generale, oltre le regole del C++