[Qt + Visual Studio 2010] Qt Add-in

[il-pollo]

Ho deciso di usare Visual C++ come compilatore per C++ su Windows perchè è di gran lunga il più compatibile con le varie librerie esterne che mi sono trovato ad utilizzare negli anni.
Fino a VS2008 però, l'ambiente di sviluppo lasciava molto a desiderare... in particolare l'autocompletamento (Intellisense). Ora pare che l'abbiano molto migliorato.

Il mio problema è: qualcuno conosce dei modi per far funzionare l'attuale add-in delle Qt su VS2010?
Avevo letto che rilasceranno una versione compatibile con le Qt 4.7... conoscete la data di rilascio precisa?

TIA

[tomminno]

Purtroppo tocca aspettare l'uscita della 4.7, prevista per l'autunno inoltrato, per l'integrazione con VS2010.
Purtroppo del plugin non vengono rilasciati i sorgenti quindi il porting anticipato non è possibile...
Al momento mi arrangio usando QtDesigner per l'editing dei file ui in contemporanea con VS2010 (per crerare i progetti invece ricorro ancora a VS2008, avere la configurazione automatica è troppo comodo)

[s0nnyd3marco]

Perche' non provi direttamente Qt creator? Io lo uso su linux e devo dire che mi trovo benissimo. In alternativa puoi provare Netbeans che ha il supporto alle librerie QT.

[tomminno]

Originariamente inviato da s0nnyd3marco

Perche' non provi direttamente Qt creator? Io lo uso su linux e devo dire che mi trovo benissimo. In alternativa puoi provare Netbeans che ha il supporto alle librerie QT.

Per quanto apprezzi QtCreator, Visual Studio è tutta un'altra cosa.
Netbeans è un pezzo che non lo uso come editor per C++, ma anche all'epoca era molto macchinoso.

[s0nnyd3marco]

Originariamente inviato da tomminno

Per quanto apprezzi QtCreator, Visual Studio è tutta un'altra cosa.
Netbeans è un pezzo che non lo uso come editor per C++, ma anche all'epoca era molto macchinoso.

In che senso macchinoso? cmq de gustibus :P

[il-pollo]

QtCreator non mi riconosceva del codice con template che ho compilato tranquillamente sia su VS che su NetBeans, mentre in NetBeans 6.9 non funzionava la creazione di progetti Qt...
inoltre, MinGW consente l'utilizzo di estensioni non standard del C++, cosa che complica molto la migrazione verso altri ambienti di sviluppo

la soluzione sarebbe VS2008 + Qt Add-in, ma non si può lavorare senza l'Intellisense di VS2010

se dovrò implementare qualche GUI prima di questo autunno, farò come l'ultima volta: userò VS2010 con quella fogna di MFC...

Thanks!

[s0nnyd3marco]

Originariamente inviato da il-pollo

QtCreator non mi riconosceva del codice con template che ho compilato tranquillamente sia su VS che su NetBeans, mentre in NetBeans 6.9 non funzionava la creazione di progetti Qt...
inoltre, MinGW consente l'utilizzo di estensioni non standard del C++, cosa che complica molto la migrazione verso altri ambienti di sviluppo

la soluzione sarebbe VS2008 + Qt Add-in, ma non si può lavorare senza l'Intellisense di VS2010

se dovrò implementare qualche GUI prima di questo autunno, farò come l'ultima volta: userò VS2010 con quella fogna di MFC...

Thanks!

Premetto che non ci ho mai giocato seriamente, ma perche' non provi WPF?

[tomminno]

Originariamente inviato da il-pollo

se dovrò implementare qualche GUI prima di questo autunno, farò come l'ultima volta: userò VS2010 con quella fogna di MFC...

Thanks!

Secondo me ti fai solo del male. Molto meglio VS2008+Qt. L'intellisense non è il massimo, ma a me ha sempre funzionato.
Poi considera che sarebbe solo per un breve periodo di transizione, il progetto sicuramente avrebbe una vita ben più lunga di questi pochi mesi all'uscita delle 4.7.

[tomminno]

Originariamente inviato da s0nnyd3marco

Premetto che non ci ho mai giocato seriamente, ma perche' non provi WPF?

A me personalmente stuzzica molto di più QML.
Gran lavoro le WPF, ma limitate a Windows, infine c'è bisogno anche di Blend, ad ogni nuova versione devi avere l'ultimo Visual Studio e l'ultimo Blend.
Insomma la spesa si fa consistente.

[cionci]

Originariamente inviato da il-pollo

QtCreator non mi riconosceva del codice con template che ho compilato tranquillamente sia su VS che su NetBeans, mentre in NetBeans 6.9 non funzionava la creazione di progetti Qt...

Se te lo compila NetBeans (che dovrebbe far uso di Cygwin) te lo deve compilare anche MinGW...
Posta un po' il codice...

Originariamente inviato da il-pollo

inoltre, MinGW consente l'utilizzo di estensioni non standard del C++, cosa che complica molto la migrazione verso altri ambienti di sviluppo

Che intendi ?

[cionci]

Originariamente inviato da tomminno

A me personalmente stuzzica molto di più QML.

Io sto sbavando all'idea di QtQuick e QML

[il-pollo]

Originariamente inviato da cionci

Se te lo compila NetBeans (che dovrebbe far uso di Cygwin) te lo deve compilare anche MinGW...
Posta un po' il codice...

//********************* Random<T> class *****************************

/*
  generates random numbers
  minValue <= x < maxValue
*/
template<typename T>
class Random{
  protected:
    T minValue, maxValue;
    virtual void init( T minValue, T maxValue );
    virtual void randomize();
  public:
    Random<T>( T maxValue ); // 0 < maxValue
    Random<T>( T minValue, T maxValue ); // minValue < maxValue
    virtual T getRandomNumber();
};


//***************** RandomIntegerBoost class ************************

/*
  uses boost library randomness
*/

// typedef for boost library random number generation
typedef boost::mt19937 base_generator_type;
typedef boost::uniform_int<> distribution_type;
typedef boost::variate_generator<base_generator_type &,
                                 distribution_type> variate_generator_type;

class RandomIntegerBoost: public Random<int>{
  // boost library random number generation
    base_generator_type * generator;
    distribution_type * distribution;
    variate_generator_type * die;
    virtual void init( int minValue, int maxValue );
    void randomize();
  public:
    RandomIntegerBoost( int maxValue ); // 0 < maxValue
    RandomIntegerBoost( int minValue, int maxValue ); // minValue < maxValue
    ~RandomIntegerBoost();
    int getRandomNumber();
};

Originariamente inviato da cionci

Che intendi ?

con MinGW è possibile compilare codice del tipo:

void f( int dimension ){
  int array[dimension];
  ...
}

mentre con VS non compila

ho letto che un'operazione simile è consentita in un'estensione particolare del C++

[tomminno]

Originariamente inviato da il-pollo

ho letto che un'operazione simile è consentita in un'estensione particolare del C++

Si un'estensione talmente particolare che è C!
Quel codice è C99. Visual Studio non supporta C99. Nè d'altra parte è qualcosa di contemplato nello standard C++

[il-pollo]

riassumendo la mia posizione in merito a MinGW vs VC++: preferisco il 2° perchè non compila codice non-standard, così si scrive direttamente tutto in una forma accettabile da altri compilatori

[il-pollo]

e poi, scusate se spammo sul mio stesso thread... ma questo è il mio 200° messaggio sul forum di HWUpgrade

[cionci]

Originariamente inviato da tomminno

Si un'estensione talmente particolare che è C!
Quel codice è C99. Visual Studio non supporta C99. Nè d'altra parte è qualcosa di contemplato nello standard C++

Tra l'altro Visual Studio 2010 supporta C++X0, quindi di fatto compila codice non standard.

[il-pollo]

bene...

mò mi ritiro in attesa delle Qt 4.7 e ringrazio ancora tutti quelli che mi hanno risposto

[cionci]

Originariamente inviato da il-pollo

con MinGW è possibile compilare codice del tipo:

void f( int dimension ){
  int array[dimension];
  ...
}

mentre con VS non compila

ho letto che un'operazione simile è consentita in un'estensione particolare del C++

Basta aggiungere -pedantic alle opzioni passate al compilatore e ti ritorna uno warning in quel caso

[cionci]

Tornando al template che non ti viene compilato: ma l'implementazione del template dov'è ?

[il-pollo]

qua c'è l'implementazione delle classi template

//******************** Random<T> methods **************************

template<typename T>
void Random<T>::randomize(){
  // initialize random seed
  srand( (unsigned int)( time( NULL ) ) );
  // ignore first number ( time dipendent )
  int _ = rand();
}

template<typename T>
void Random<T>::init( T minValue, T maxValue ){
  this->minValue = minValue;
  this->maxValue = maxValue;
  randomize();
}

template<typename T>
Random<T>::Random( T maxValue ){ init( 0, maxValue ); }

template<typename T>
Random<T>::Random( T minValue, T maxValue ){ init( minValue, maxValue ); }

template<typename T>
T Random< T >::getRandomNumber(){
  return (T)( ( (maxValue-minValue)*(double)rand()/(double)(RAND_MAX) ) +
              minValue ) ;
}


//**************** RandomIntegerBoost methods ***********************

void RandomIntegerBoost::randomize(){

  /*
    Change seed to something else.

    Caveat: std::time(0) is not a very good truly-random seed.
    When called in rapid succession, it could return the same
    values, and thus the same random number sequences could ensue.
    If not the same values are returned, the values differ only
    slightly in the lowest bits. A linear congruential generator
    with a small factor wrapped in a uniform_smallint will
    produce the same values for the first few iterations.
    This is because uniform_smallint takes only the highest bits
    of the generator, and the generator itself needs a few
    iterations to spread the initial entropy from the lowest bits
    to the whole state.
  */
  generator->seed( static_cast<unsigned int>( time( NULL ) ) );
}

void RandomIntegerBoost::init( int minValue, int maxValue ){
  /* the seed is unsigned, otherwise the wrong
     overload may be selected when using mt19937
     as the base_generator_type */
  generator = new base_generator_type( (unsigned int)time( NULL ) );

  /* uniform random number distribution of
     integer values in [ minValue, maxValue ) */
  distribution = new distribution_type( minValue, maxValue-1 );
  die = new variate_generator_type( *generator, *distribution );
}

RandomIntegerBoost::RandomIntegerBoost( int maxValue ):
  Random<int>( maxValue ){ init( 0, maxValue ); }

RandomIntegerBoost::RandomIntegerBoost( int minValue, int maxValue ):
  Random<int>( minValue, maxValue ){ init( minValue, maxValue ); }

RandomIntegerBoost::~RandomIntegerBoost(){
  delete die;
  delete distribution;
  delete generator;
}

int RandomIntegerBoost::getRandomNumber(){
  return (*die)();
}