[MFC] CArray dans Copyfrom

**Gloubi99** · 21/07/2005, 19h15

Bonjour

En faisant dans OnInitialupdate de CAngelView

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
CClasse classe;
classe.sonnomclasse="4°1";
classe.sasalleclasse.Add("salle 14");        <-------------- plantage
pTheApp->mesclasses.Add(classe);         // pTheApp recup avant ds le prog

j'ai

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
c:\Program Files\Microsoft Visual Studio\MyProjects\angel 21 7 14 04 juste apres chgt CArray et 0 bug\angelView.cpp(104) : error C2664: 'CArray<TYPE,ARG_TYPE>::Add' : impossible de convertir le paramètre 1 de 'const char [9]' en 'ATL::CStringT<BaseType,StringTraits> '
        with
        [
            TYPE=CString,
            ARG_TYPE=CString &
        ]
        and
        [
            BaseType=char,
            StringTraits=StrTraitMFC<char>
        ]
        Une référence qui ne retourne pas à 'const' ne peut pas être liée à une non-lvalue

pourtant "sasalleclasse" est bien un CArray de CString déclaré dans CClasse. Ca me rapelle la meme erreur que la fois dernière

Attention aussi sur les declarations d'objets utilisés avec des conteneurs .
pour inserer dans une CList ou CArray le contructeur de copie ou l'operateur d'affection (de l'objet) suivant les cas est appelé .
il convient donc dans le cas d'un objet classe de prendre l'habitude de founir ces methodes.

j'ai donc essayer d'ajouter mon CArray dans le "void copyfrom"
et là, gros plantage. Je suppose qu'il doit y avoir un truc particulier à faire quand il s'agit d'un CArray.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
#pragma once
 
class CClasse : public CObject
{
public:
    DECLARE_SERIAL( CClasse )
 
    CClasse(){Clear();}
    //-----------------------------
    ~CClasse(){}
    //-----------------------------
    // constructeur de copie
    CClasse(const CClasse &rItem)
    {
        CopyFrom(rItem);
    }
    //-----------------------------
    // operateur d'affectation
    const CClasse& operator=(const CClasse& Src)
    {
        CopyFrom(Src);
        return *this;
    }
    //-----------------------------
    // effacer les données.
    void Clear()
    {
        sonnomclasse="";
       // manque clear du CArray
          }
    //-----------------------------
    // la methode de serialisation.
    void Serialize(CArchive& ar)
    {
        if(ar.IsStoring())
            ar << sonnomclasse  << sasalleclasse      //test n°1   !!!!!!!!!
        else
            ar >> sonnomclasse  ;
    }
    //-----------------------------
    // copier les données d'une source.
    void CopyFrom(const CClasse & Src )
    {
        if(this==&Src) return;
 
        //Clear(); // clear eventuel.
 
        sonnomclasse    = Src.sonnomclasse;
        sasalleclasse = Src.sasalleclasse;             // test n°2 !!!!!!!!!!!!!!!!!!!
 
   }
    //-----------------------------
    // dump pour test
    CString GetStrDump()
    {
        //return ( sasalleclasse);
    }
 
    // les données.
    CString sonnomclasse;
    CArray<CString,CString&> sasalleclasse;
};
// la gestion d'un tableau de cette classe .
typedef CArray<CClasse,CClasse&> CArrayClasse;

Erreur pour le test 1:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Classe.h(37) : error C2678: '<<' binaire : aucun opérateur trouvé qui accepte un opérande de partie gauche de type 'CArchive' (ou il n'existe pas de conversion acceptable)

Erreur pour le test 2:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Classe.h(50) : error C2582: 'operator =' fonction non disponible dans 'CArray<TYPE,ARG_TYPE>'

Quelle(s) modification(s) dois-je faire à ma classe pour qu'elle fonctione et plus tard pour qu'elle serialise.
Si tu connais un tuto du genre de CItem mais qui gère un Carray, je suis aussi preneur.
D'avance un enorme merci.

**farscape** · 21/07/2005, 20h50

re,
declare ton CArray comme ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
CArray<CString, LPCSTR> sasalleclasse

**farscape** · 21/07/2005, 21h39

pas de panique

,pour serialiser le CArray :
celui ci ne dispose pas des operateurs << >> .
exemple appliqué a la classe CItem:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
class CItem : public CObject
{
 
public:	
    DECLARE_SERIAL( CItem )
 
    CItem(){Clear();}
    //-----------------------------
    ~CItem(){}
    //-----------------------------
    CItem(const CItem &rItem)
    {
        CopyFrom(rItem);
    }
    //-----------------------------
	const CItem& operator=(const CItem& Src)
    {
        CopyFrom(Src);
		return *this;
    }
    //-----------------------------
    void Clear()
    {
        m_strNom="";
        m_strPrenom="";
        m_strCdp="";
        m_strVille=""; 
        m_arString.RemoveAll();
    }
    //-----------------------------
    void Serialize(CArchive& ar)
    {
		if(ar.IsStoring())					        
			ar << m_strNom << m_strPrenom << m_strCdp <<m_strVille ;                    
		else		
			ar >> m_strNom >> m_strPrenom >> m_strCdp >> m_strVille;
        m_arString.Serialize(ar);
	}
    //-----------------------------
	void CopyFrom(const CItem & Src )
    {
        if(this==&Src) return;
 
	    Clear(); // clear eventuel.
 
        m_strNom    =Src.m_strNom;
        m_strPrenom =Src.m_strPrenom;
        m_strCdp    =Src.m_strCdp;
        m_strVille  =Src.m_strVille;
        for(int i=0;i<Src.m_arString.GetSize();i++)        
            m_arString.Add(Src.m_arString[i]);
	}
    //-----------------------------
    CString GetStrDump()
    {
        CString str=( m_strNom + "/" +m_strPrenom + "/" + m_strCdp +"/" + m_strVille);
        for(int i=0;i<m_arString.GetSize();i++)
        {
            str+="/";
            str+=m_arString[i];
        }
        return str;
    }
 
 
    CString m_strNom;
    CString m_strPrenom;
    CString m_strCdp;
    CString m_strVille;
    CArray<CString ,LPCSTR> m_arString;
};

**Gloubi99** · 22/07/2005, 00h09

Salut Farscape

Comme d'habitude, les réponses sont nickel. Un merci de plus.

histoire de comprendre les modifs, ( j'ai horreur de ne pas comprendre !)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

CArray<CString, LPCSTR> sasalleclasse

LPCSTR: j'ai été voir MSDN ça m'a pas convaincu !

d'après mon bouquin, le 2eme argument correspond au type à utiliser dans les appels aux fonctions membres.
pourquoi le fait de remplacer CString& par LPCSTR fait que ca marche?
la (es) fonctions ne peuvent pas etre appelé avec un type référence CString. Comment tu trouves ce qu'il faut mettre ?
Sur le bouquin, ils disent qu'il faut mettre une référence !!!!!!!!
---------------------------------------------------------------------------------------------------------------

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
void Serialize(CArchive& ar) 
    { 
      if(ar.IsStoring())                       
         ar << m_strNom << m_strPrenom << m_strCdp <<m_strVille ;                    
      else       
         ar >> m_strNom >> m_strPrenom >> m_strCdp >> m_strVille; 
 
        m_arString.Serialize(ar);

Quelques affirmations de ce que j'ai compris de ton code ci-dessus . Si tu peux confirmer si c'est juste.

le .Serialize(ar), c'est la fonction qui derive de CObject. ce n'est pas la fonction qui s'appelle elle meme.
comme CString, Cpoint, int ... ne derive pas de CObject, on est obligé d'utiliser les opérateurs de direction. On ne peut pas écrire MonCString.Serialize(ar)
dans .Serialize(ar), on ne precise pas le sens de l'archivage, c'est la fonction qui s'en occupe toute seule.

Merci (et Bonne nuit le cas échéant)

**farscape** · 22/07/2005, 09h07

salut,
Pour le const char * la raison est simple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
AFX_INLINE int CArray<TYPE, ARG_TYPE>::Add(ARG_TYPE newElement)

si on declare CArray<CString ,CString &> on ne pourra mettre une chaîne en argument de Add.
Une chaîne n’est pas compatible avec CString & ,
Le type de donnée idoine sera donc dans ce cas const char *
Puisque la CString dispose de l’opérateur, permettant ainsi de passer une chaîne et une CString en argument.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
CArray<CString,CString &> arstr;
CString str="toto";
arstr.Add(str); // accepté

MSDN dit (traduit dans le texte )arg_typ est le plus souvent la reference de type .
Tout dépend de ce que l’on passe en argument.

1)
oui ,bien que je n’ai pas bien compris ton probleme.

CObject::Serialize

virtual void Serialize(
CArchive& ar );

Tous les objets dérivants de CObject possèdent une méthode sérialisation.
On peut donc utiliser directement la fonction serialize de l’objet.
Dans le cas cité on ne fait que transmettre l’archive en cours a un objet pour qu’il se sauvegarde ou qu’il se charge.

2) oui
il suffit de regarder les types supportés par les opérateurs de flux dispos dans la classe CArchive.

3) oui ,une archive s’ouvre dans soit en lecture ou écriture exclusivement .
Les fonctions :

CArchive::IsStoring
BOOL IsStoring( ) const;
CArchive::IsLoading
BOOL IsLoading( ) const

Permettent de déterminer le mode en cours.