Errori, bug, domande - pagina 1730

Nuovo commento
 
Ilyas:
Esatto, qui nella digitazione, T = A *

Allora c'è un errore di compilazione qui

template<typename T>
void f1( const T  const & a[] ) {} //error: 'const' - unexpected token
class A {};
void f2( const A* const & a[] ) {}
class B {
        void g1() const { f1( a ); }
        void g2() const { f2( a ); }
        A *a[];
};
 
Sergei Vladimirov:
Esattamente. Ho letto tutte queste affermazioni e ancora non riesco a capire dove sia il problema. Avete intenzione di memorizzare questi file su un floppy disk?


Si consuma il disco quando si salva un file di 100K invece di uno di 50K? (Non è divertente per voi? )

Ed è normale che a causa di un singolo carattere di copyright (che in linea di principio è internazionale e si trova in tutte le codifiche, anche se il suo codice è maggiore di 127) la dimensione del file venga raddoppiata senza alcun senso? Non è intelligente? Perché gonfiare i file di 2 volte senza alcuna necessità?

Il problema non è solo la dimensione, ma anche la ricerca contestuale. Finché i file sono in ASCII, puoi usare molti programmi di terze parti, inclusi i file manager, per cercare i file usando la stringa di contesto. Lo uso quasi ogni giorno. L'editor nativo di MQ è un buco nell'acqua in questo senso come in molti altri problemi di codifica evidenti. Una volta che abbiamo l'unicode, la ricerca nel contesto ha due problemi: non tutti i programmi possono o vogliono farlo, e per quelli che possono, abbiamo il punto 2 - la lentezza.

Naturalmente, alcune persone trovano più facile comprare un computer più veloce oltre al disco rigido che pensare o almeno imparare da altri prodotti come dovrebbe essere il software user-friendly ed efficiente.

 
A100:

Allora c'è un errore di compilazione qui

Anche in C++ c'è ambiguità del tipo: const T const

Ma c'è una via d'uscita: spostare la costola a destra

template<typename T>
void f1(  T         const & a[] ) {} //error: 'const' - unexpected token
class A {};
void f2(  A const * const & a[] ) {} //нормально
class B {
        void g1() const { f1( a ); } //error: 'f1' - cannot to apply function template
        void g2() const { f2( a ); } //нормально
        A *a[];
};
C++ si compila senza errori (considerando la differenza di sintassi)
 
A100:

Anche in C++ c'è l'ambiguità del tipo: const T const

Ma c'è una via d'uscita: spostare la costola a destra

C++ si compila senza errori (data la differenza di sintassi)

Ma logicamente è strano quando "const A" e "A const" significano la stessa cosa.

Forse"Aconst*" è un puntatore costante a un oggetto non-const.

Questo sembra essere il caso. Perché un tale costrutto esiste.

class A {};
void f( const A const * const & a[] ) {}

Non si può cambiare il puntatore, non si può cambiare per riferimento e non si può cambiare l'oggetto o gli oggetti.

Dal punto di vista dell'ottenimento di codice veloce, un tale costrutto potrebbe dare al compilatore un suggerimento adeguato?

 
Stanislav Korotky:

È normale che un singolo carattere di copyright (che in linea di principio è internazionale ed è presente in tutte le codifiche, nonostante il fatto che il suo codice sia più grande di 127) faccia aumentare di due volte la dimensione del file...

Sì. A tutti gli effetti, non vedo il senso di risparmiare sulle partite.
 
È interessante che in questa costruzione
class A {};
void f( const A const * & a[] ) {}

Non potete cambiare gli elementi, ma potete cambiare la dimensione dell'array.

Divertente, si scopre che i metodi possono assomigliare a questo

class A {};
class B
{
  const A const * Method( const A const * const & a[] ) const
  {
    return(a[0]);
  }
};
 
fxsaber:

È possibile che"Aconst*" sia un puntatore costante non a un oggetto costante.

Se non è un modello, allora "A const *" è uguale a "const A *", e se è un modello, per quella situazione (in C++)
 
A100:
Se non è un modello, allora "A const *" è uguale a "const A *", e se è un modello, allora per situazione
Quindi non ci dovrebbe essere alcuna equivalenza. MQL lo considera equivalente, tuttavia
class A
{
public:
  int i;
};

void f( A const * & a[] )
{
  a[0].i = 1; // 'i' - constant cannot be modified
}
Secondo me, qui c'è un errore. Perché è un array di puntatori costanti (const *) che viene passato, non un array di puntatori a oggetti costanti(const A).
 
A100:
In particolare questo - fissato nel futuro https://www.mql5.com/ru/forum/1111/page1749#comment_2892563
Allora non ci dovrebbe essere alcuna equivalenza nella tua affermazione
A100:
Se non è un modello, allora "A const *" è uguale a "const A *", e se è un modello - per quella situazione (in C++)
 
fxsaber:
È interessante che in un design come questo...
class A {};
void f( const A const * & a[] ) {}

non possono essere cambiati, ma la dimensione dell'array può essere cambiata.

Davvero? È un peccato, non dovrebbe essere così.
1...172317241725172617271728172917301731173217331734173517361737...3184
Nuovo commento