Erreurs, bugs, questions - page 1569

[A100]

Erreur de compilation (build 1327)

class A { 
public:
        bool operator++( int ) { return false; }
};

void OnStart()
{
        A a;
        while ( a++ ); //'++' - illegal operation use
}

[A100]

Erreur de compilation

class A { public:
template<typename T>        void f( T t );
template<typename T> static void g( T t );
}; 
template<typename T> void A::f( T t ) {}
template<typename T> void A::g( T t ) {}

void OnStart()
{
        A a;
        a.f(  1 ); //нормально
        A::g( 1 ); //'g<int>' - access to non-static member or function
}

[A100]

Erreur de compilation

class A { public:
        A *operator ++()      { return &this; }
};
template<typename T> void f( T t ) {}
void g( A *a )
{
        f( ++a ); //'A' - declaration without type (1)
        f( a.operator++()); //нормально            (2)
}

Note spéciale - si vous intervertissez ( !) les lignes (1) et (2), tout va bien, ce qui nécessite une vérification supplémentaire.

[[Supprimé]]

A100:

Erreur de compilation

Je tiens à souligner que si vous intervertissez( !) les lignes (1) et (2), tout va bien, ce qui nécessite une vérification supplémentaire

Est-ce que je comprends bien que f(++a) et f(a++) provoquent des variantes différentes de f dans votre exemple ?

[A100]

Anton Zverev:
Est-ce que je comprends bien que f(++a) et f(a++) provoquent des variantes différentes de f dans votre échantillon ?

Non, il s'agit d'une erreur de compilation - c'est-à-dire qu'il n'y a pas encore eu d'exécution (appels spécifiques). Les chaînes (1) et (2) sont équivalentes du point de vue du code (écriture différente de la même chose).

Voici un autre exemple pour ne pas donner l'impression qu'il s'agit uniquement de l'opérateur ++.

class A { public:
        A *operator <<( int )      { return &this; }
};
template<typename T> void f( T* t ) {}
void g( A* a )
{
        f( a << 1 ); //'A' - declaration without type
}

[[Supprimé]]

A100:

Les lignes (1) et (2) sont équivalentes en termes de code (écriture différente de la même chose).

++a et a++ sont néanmoins différents en termes de signification. Tu ne crois pas ?

[A100]

Anton Zverev:
++a et a++ ont, après tout, un sens différent. Tu ne crois pas ?

il n'y a pas de a++

[A100]

Erreur de compilation : erreur d'optimisation de l'arbre

#property library

class A { public:
template<typename T> int f( T a, int b, bool c = false );
};
template<typename T>
int A::f( T a, int b, bool c ) { return 0; }

class B : public A {
        virtual void g();
};
void B::g()
{
        f( 0, 0, false ); //нормально
        f( 0, 0 );        //tree optimization error
}

class C {};
void start( C* ) export {}

Comme'l'erreur d'optimisation de l'arbre' n'est pas facile à localiser, je demande aux développeurs (s'ils ont cette possibilité) de mettre toute l'optimisation dans la clé d'optimisation (Dieu merci, elle existe), sinon même avec l'optimisation désactivée, les programmes qui fonctionnent s'avèrent être complètement désactivés après la mise à jour de la version (et il est impossible de revenir en arrière).

Notez que toutes les erreurs d'aujourd'hui ne sont pas anciennes, mais nouvelles - avant (build 1241) tout fonctionnait.

[[Supprimé]]

A100:
il n'y a pas de A++.

Bien. C'est pourquoi je l'ai rendu plus spécifique.

Anton Zverev:
Est-ce que je comprends bien que f(++a) et f(a++) provoquent des variantes différentes de f dans votre exemple ?

[A100]

Nécessité d'affiner les modèles (prendre l'implémentation en dehors de la classe A {})

template<typename T>
class A { public:
template<typename T2>
        void f1( T2 t2 );
template<typename T2>
        void f2( T2 t2, T tt ) { Print( __FUNCSIG__, " ", typename( this.t ) ); }
template<typename T2>
        void f3( T2 t2, T tt );
        T t;
};
template<typename T>
template<typename T2>
void A::f1( T2 t2 )       { Print( __FUNCSIG__, " ", typename( this.t ) ); } //нормально
template<typename T>
template<typename T2>
void A::f3( T2 t2, T tt ) { Print( __FUNCSIG__, " ", typename( this.t ) ); } // error: 'T' - declaration without type

Je ne peux pas implémenter A::f3 en dehors de la classe A {}.

Mais à l'intérieur de la classe A {}, vous pouvez. Oui, vous pouvez... par exemple, f2(), mais l'inconvénient réside dans le but de prendre des fonctions encombrantes en dehors de la classe A {}. L'essentiel est que A::f1() peut être amené à l'intérieur de la classe A {} et que tout fonctionne alors que A::f3() ne peut pas - le compilateur génère une erreur.