none
les problèmes restants RRS feed

  • Question

  • Je suis toujours en train de migrer le code de java.

    J'ai bien avancé mais j'ai deux constructions qui sont refusées par le compilateur avec le même diagnostique et une autre avec un différent diagnostique.

    Je vous met les deux races de problèmes avec les déclaration des classes et pour chaque problème une illustration des code qui posent problème et le diagnostique du compilateur.

        

    class Terme
        {
          public:
            Terme* Implique;
            std::wstring wsOrigine;
            std::wstring wsTerme;
            std::wstring wsDeclencheur;
            std::wstring wsIdentifier;
            std::wstring wsValueOfWords;
            std::wstring ListParagraph;
            std::wstring wskeyValue;
            std::wstring operande;
            std::wstring wsText;
            std::list<CWord*> Word;
            bool bStatus;
        };

    class CObjet { public: CObjet* Comprend; std::wstring Name; std::wstring Text; bool Valid; Cobjet* inherit; std::list<std::wstring*> Enumerated; int nValue; int min; int max; int type; int step; };

    les déclarations des variables en cause

    CObjet* pCurrentObject;
    Terme terme;

    tout se passe dans la première méthode

    int assertCoherence::ExtractElements( std::list<CObjet*> ListObjectsNormalized, std::wstring ValueToCheck, std::wstring NameToCheck)
        {
            std::list<CObjet*>::iterator itObjet;
            std::list<std::wstring>::iterator itWord;
            CObjet* pFirstObject;
            CObjet* pCurrentObject;
            bool bFirstObject = true;
            int j = 0;
            int k = 0;
            int iEffectif = 0;
            int iNull = 0;
            

            pCurrentObject = new CObjet();
            pFirstObject = new CObjet();
            plisteTermeToCheck = new std::list<Terme*>();
            itObjet = ListObjectsNormalized.begin();
            while( itObjet != ListObjectsNormalized.end())
            { // 2
                pCurrentObject = *itObjet;
                if( bFirstObject == true)
                { // 3
                    pFirstObject = pCurrentObject;
                    bFirstObject = false;
                } // 3
    176         if( pCurrentObject->Enumerated != NULL)
                {
                    j = pCurrentObject->Enumerated.size();
                }
                else
                {
                    j = 0;
                }
                k = 0;
                if( j > 0)
                {
    187             itWord = pCurrentObject->Enumerated.begin();
    188             while( itWord != pCurrentObject->Enumerated.end())
                    { // 4
                         ValueToCheck[ iEffectif] = *itWord;
                        NameToCheck[ iEffectif] = ( wchar_t)pCurrentObject->Name.c_str();
                        iEffectif++;
                        if( pCurrentObject->nValue > 0)
                        { // 5
                            // si iEffectif est pair
                            if( 1 == odd( iEffectif))
                            { // 6
                                // wchar_t * _itow( int value, wchar_t *str, int radix)
                                std::wstring wsTemp;
                                wsTemp = _itow( pCurrentObject->max, ( wchar_t *)wsTemp.c_str(), 10);
                                ValueToCheck[ iEffectif] = ( wchar_t)wsTemp.c_str();
                                NameToCheck[ iEffectif] = ( wchar_t)pCurrentObject->Name.c_str();
                            }
                            else
                            { // 6
                                // wchar_t * _itow( int value, wchar_t *str, int radix);
                                std::wstring wsTemp;
                                wsTemp = _itow( pCurrentObject->max, ( wchar_t *)wsTemp.c_str(), 10);
                                ValueToCheck[ iEffectif] = ( wchar_t)wsTemp.c_str();
                                NameToCheck[ iEffectif] = ( wchar_t)pCurrentObject->Name.c_str();
                            }
                       } // 5
                       else
                       { // 5
                            iNull++;
                            ValueToCheck[ k] =  ( wchar_t)L"";
                            NameToCheck[ k] =  ( wchar_t)L"";
                       } // 5
                       j++;
                       itWord++;
                    } // 4
                } // 3
                itObjet++;
            } // 2
            return( iEffectif);
        }

    le diagnostique du compilateur

    1>  AssertCoherence.cpp
    1>..\..\..\..\Linguistic\Coherence\src\AssertCoherence.cpp(176): error C2678: '!=' binaire : aucun opérateur trouvé qui accepte un opérande de partie gauche de type 'std::list<_Ty>' (ou il n'existe pas de conversion acceptable)
    1>          with
    1>          [
    1>              _Ty=std::wstring *
    1>          ]
    1>          e:\Program Files\Microsoft Visual Studio 10.0\VC\include\system_error(425): peut être 'bool std::operator !=(const std::error_code &,const std::error_condition &)'
    1>          e:\Program Files\Microsoft Visual Studio 10.0\VC\include\system_error(432): ou       'bool std::operator !=(const std::error_condition &,const std::error_code &)'
    1>          C:\Program Files\Microsoft SDKs\Windows\v7.0A\include\guiddef.h(197): ou       'int operator !=(const GUID &,const GUID &)'
    1>          lors de la tentative de mise en correspondance de la liste des arguments '(std::list<_Ty>, int)'
    1>          with
    1>          [
    1>              _Ty=std::wstring *
    1>          ]
    1>..\..\..\..\Linguistic\Coherence\src\AssertCoherence.cpp(187): error C2679: '=' binaire : aucun opérateur trouvé qui accepte un opérande de partie droite de type 'std::_List_iterator<_Mylist>' (ou il n'existe pas de conversion acceptable)
    1>          with
    1>          [
    1>              _Mylist=std::_List_val<std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>> *,std::allocator<std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>> *>>
    1>          ]
    1>          e:\Program Files\Microsoft Visual Studio 10.0\VC\include\list(393): peut être 'std::_List_iterator<_Mylist> &std::_List_iterator<_Mylist>::operator =(const std::_List_iterator<_Mylist> &)'
    1>          with
    1>          [
    1>              _Mylist=std::_List_val<std::wstring,std::allocator<std::wstring>>
    1>          ]
    1>          lors de la tentative de mise en correspondance de la liste des arguments '(std::_List_iterator<_Mylist>, std::_List_iterator<_Mylist>)'
    1>          with
    1>          [
    1>              _Mylist=std::_List_val<std::wstring,std::allocator<std::wstring>>
    1>          ]
    1>          and
    1>          [
    1>              _Mylist=std::_List_val<std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>> *,std::allocator<std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>> *>>
    1>          ]
    1>..\..\..\..\Linguistic\Coherence\src\AssertCoherence.cpp(188): error C2678: '!=' binaire : aucun opérateur trouvé qui accepte un opérande de partie gauche de type 'std::_List_iterator<_Mylist>' (ou il n'existe pas de conversion acceptable)
    1>          with
    1>          [
    1>              _Mylist=std::_List_val<std::wstring,std::allocator<std::wstring>>
    1>          ]
    1>          e:\Program Files\Microsoft Visual Studio 10.0\VC\include\system_error(425): peut être 'bool std::operator !=(const std::error_code &,const std::error_condition &)'
    1>          e:\Program Files\Microsoft Visual Studio 10.0\VC\include\system_error(432): ou       'bool std::operator !=(const std::error_condition &,const std::error_code &)'
    1>          C:\Program Files\Microsoft SDKs\Windows\v7.0A\include\guiddef.h(197): ou       'int operator !=(const GUID &,const GUID &)'
    1>          e:\Program Files\Microsoft Visual Studio 10.0\VC\include\list(298): ou       'bool std::_List_const_iterator<_Mylist>::operator !=(const std::_List_const_iterator<_Mylist> &) const'
    1>          with
    1>          [
    1>              _Mylist=std::_List_val<std::wstring,std::allocator<std::wstring>>
    1>          ]
    1>          lors de la tentative de mise en correspondance de la liste des arguments '(std::_List_iterator<_Mylist>, std::_List_iterator<_Mylist>)'
    1>          with
    1>          [
    1>              _Mylist=std::_List_val<std::wstring,std::allocator<std::wstring>>
    1>          ]
    1>          and
    1>          [
    1>              _Mylist=std::_List_val<std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>> *,std::allocator<std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>> *>>
    1>          ]
    1>..\..\..\..\Linguistic\Coherence\src\AssertCoherence.cpp(188): fatal error C1903: impossible de récupérer à partir des erreurs précédentes ; arrêt de la compilation
    ]

    Je ne sais pas comment m'en sortir. Je suis bloqué,. Pouvez vous m'aider?


    Jean Noël Martin





    • Modifié JeanNoel53 samedi 12 octobre 2013 19:38
    samedi 12 octobre 2013 08:46

Réponses

Toutes les réponses

  • Bonjour,

    L'erreur ">..\..\..\..\Linguistic\Coherence\src\AssertCoherence.cpp(176):error C2678: '!='binaire :aucun opérateur " et le correspond à quelle ligne exactement dans votre code source ?

    Cordialement


    Gilles TOURREAU - MVP C#
    Architecte logiciel/Consultant/Formateur Freelance - P.O.S Informatique
    Blog : http://gilles.tourreau.fr - Suivez-moi sur Twitter
    - MCPD : Enterprise Developper / Windows Developper 3.5 / ASP .NET 3.5/4.0
    - MCSA : SQL Server 2012
    - MCITP : SQL Server 2008 Developper
    - MCTS : ADO .NET 3.5 / SQL Server 2008 Developper / Windows Forms 3.5 / ASP .NET 3.5/4.0 / TFS 2010 / Windows Azure

    lundi 14 octobre 2013 00:06
    Modérateur
  • lignes 176, 187 et 188 qui sont numérotés dans le source

    Jean Noël Martin

    lundi 14 octobre 2013 01:14
  • Bonjour,

    La condition suivante sera toujours vraie car le champ Enumerated n'est pas un pointeur, donc vous n'avez pas à faire de "if".

     if( pCurrentObject->Enumerated != NULL)
    

    Déclarer votre variable itWord comme ceci (liste de pointeur de wstring) :

    std::list<std::wstring*>::iterator itWord;
    

    Cordialement


    Gilles TOURREAU - MVP C#
    Architecte logiciel/Consultant/Formateur Freelance - P.O.S Informatique
    Blog : http://gilles.tourreau.fr - Suivez-moi sur Twitter
    - MCPD : Enterprise Developper / Windows Developper 3.5 / ASP .NET 3.5/4.0
    - MCSA : SQL Server 2012
    - MCITP : SQL Server 2008 Developper
    - MCTS : ADO .NET 3.5 / SQL Server 2008 Developper / Windows Forms 3.5 / ASP .NET 3.5/4.0 / TFS 2010 / Windows Azure

    lundi 14 octobre 2013 18:13
    Modérateur
  • Je conclue que en C++ cette variable est toujours initialisé, contrairement à Java.

    Jean Noël Martin

    • Marqué comme réponse JeanNoel53 lundi 14 octobre 2013 18:33
    • Non marqué comme réponse JeanNoel53 lundi 14 octobre 2013 18:33
    • Marqué comme réponse JeanNoel53 lundi 14 octobre 2013 18:33
    lundi 14 octobre 2013 18:33
  • NON.

    "A a;" déclare un objet de nom a, de type A, et l'initialise avec le constructeur sans paramètre de la classe A.

    "A* a;" déclare un pointeur sur un objet A, mais ne l'initialise pas.


    Paul Bacelar, Ex - MVP VC++

    lundi 25 novembre 2013 14:57
    Modérateur