[STL] problème lors de l'utilisation de l'algorithme copy()

Version imprimable

Bonsoir,
J'ai essayé de suivre les explication sur l'algorithme de Huffman (histoire de m'instruire d'avantage et de me perfectionner en C++)...
j'ai voulu tester la cocherence d'une hierarchie de neuds, mais j'obtiens une erreur à la compilation:

Citation:

-------------- Build: Debug in Huffman ---------------
Compiling: main.cpp
C:/MinGW/include/c++/3.2.3/bits/ios_base.h: In copy constructor
`std::basic_ios<char, std::char_traits<char> >::basic_ios(const
std::basic_ios<char, std::char_traits<char> >&)':
C:/MinGW/include/c++/3.2.3/bits/ios_base.h:424: `std::ios_base::ios_base(const
std::ios_base&)' is private
C:/Documents and Settings/U502136/Mes documents/C++/Huffman/main.cpp:13: within
this context
C:/Documents and Settings/U502136/Mes documents/C++/Huffman/main.cpp: In
function `int main()':
C:/Documents and Settings/U502136/Mes documents/C++/Huffman/main.cpp:13:
initializing argument 3 of `_OutputIter std::copy(_InputIter, _InputIter,
_OutputIter) [with _InputIter = std::_List_iterator<bool, bool&, bool*>,
_OutputIter = std::basic_ostream<char, std::char_traits<char> >]'
C:/MinGW/include/c++/3.2.3/bits/stl_algobase.h: In function `_OutputIter
std::__copy(_InputIter, _InputIter, _OutputIter, std::input_iterator_tag)
[with _InputIter = std::_List_iterator<bool, bool&, bool*>, _OutputIter =
std::basic_ostream<char, std::char_traits<char> >]':
C:/MinGW/include/c++/3.2.3/bits/stl_algobase.h:266: instantiated from `_OutputIter std::__copy_aux2(_InputIter, _InputIter, _OutputIter, __true_type) [with _InputIter = std::_List_iterator<bool, bool&, bool*>, _OutputIter = std::basic_ostream<char, std::char_traits<char> >]'
C:/MinGW/include/c++/3.2.3/bits/stl_algobase.h:303: instantiated from `_OutputIter std::__copy_ni2(_InputIter, _InputIter, _OutputIter, __false_type) [with _InputIter = std::_List_iterator<bool, bool&, bool*>, _OutputIter = std::basic_ostream<char, std::char_traits<char> >]'
C:/MinGW/include/c++/3.2.3/bits/stl_algobase.h:323: instantiated from `_OutputIter std::__copy_ni1(_InputIter, _InputIter, _OutputIter, __false_type) [with _InputIter = std::_List_iterator<bool, bool&, bool*>, _OutputIter = std::basic_ostream<char, std::char_traits<char> >]'
C:/MinGW/include/c++/3.2.3/bits/stl_algobase.h:349: instantiated from `_OutputIter std::copy(_InputIter, _InputIter, _OutputIter) [with _InputIter = std::_List_iterator<bool, bool&, bool*>, _OutputIter = std::basic_ostream<char, std::char_traits<char> >]'
C:/Documents and Settings/U502136/Mes documents/C++/Huffman/main.cpp:13: instantiated from here
C:/MinGW/include/c++/3.2.3/bits/stl_algobase.h:227: no match for `++
std::basic_ostream<char, std::char_traits<char> >&' operator
C:/MinGW/include/c++/3.2.3/bits/stl_algobase.h:266: instantiated from `_OutputIter std::__copy_aux2(_InputIter, _InputIter, _OutputIter, __true_type) [with _InputIter = std::_List_iterator<bool, bool&, bool*>, _OutputIter = std::basic_ostream<char, std::char_traits<char> >]'
C:/MinGW/include/c++/3.2.3/bits/stl_algobase.h:303: instantiated from `_OutputIter std::__copy_ni2(_InputIter, _InputIter, _OutputIter, __false_type) [with _InputIter = std::_List_iterator<bool, bool&, bool*>, _OutputIter = std::basic_ostream<char, std::char_traits<char> >]'
C:/MinGW/include/c++/3.2.3/bits/stl_algobase.h:323: instantiated from `_OutputIter std::__copy_ni1(_InputIter, _InputIter, _OutputIter, __false_type) [with _InputIter = std::_List_iterator<bool, bool&, bool*>, _OutputIter = std::basic_ostream<char, std::char_traits<char> >]'
C:/MinGW/include/c++/3.2.3/bits/stl_algobase.h:349: instantiated from `_OutputIter std::copy(_InputIter, _InputIter, _OutputIter) [with _InputIter = std::_List_iterator<bool, bool&, bool*>, _OutputIter = std::basic_ostream<char, std::char_traits<char> >]'
C:/Documents and Settings/U502136/Mes documents/C++/Huffman/main.cpp:13: instantiated from here
C:/MinGW/include/c++/3.2.3/bits/stl_algobase.h:228: no match for `*
std::basic_ostream<char, std::char_traits<char> >&' operator
Process terminated with status 1 (0 minutes, 1 seconds)
13 errors, 0 warnings

voici le code de ma fonction main (dans laquelle je teste mon algo):
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 #include <iostream> #include "cnode.h" #include <algorithm> using namespace std; using namespace huffman; int main() { cNode * node = new cNode(); node->setCaractere('a'); cNode node2 = new cNode(node); list<bool> &code = * node->getCode(); copy(code.begin(), code.end(), cout); cout << endl; return 0; }
Je trouve étrange qu'il soir impossible à un constructeur de faire appelle à une fonction privée d'une même classe. Je me doute donc que ces erreurs en cachent d'autres. A quel momentme suis-je planté?

03/04/2007, 17h01
blubz

c'est normal que ton node2 ne soit pas un pointeur ?
03/04/2007, 17h18
Ulmo

Il faudrait voir plus en détail ta classe cNode. Y a-t-il un operateur de copie public ?

Code:

copy(code.begin(), code.end(), cout);

Comment copies-tu des booléens dans std::cout ?
03/04/2007, 20h31
alskaar

ca marchera mieux avec un iterator :

Code:

copy(code.begin(), code.end(), ostream_iterator<bool>(cout,"\n"));

Citation:

Envoyé par blubz

c'est normal que ton node2 ne soit pas un pointeur ?

Oui, un oubli de ma part.

Citation:

Il faudrait voir plus en détail ta classe cNode. Y a-t-il un operateur de copie public ?
Code :

Citation:

copy(code.begin(), code.end(), cout);

Comment copies-tu des booléens dans std::cout ?

Je me suis simplement contenté de suivre les exemples que j'avais vu, de l'utilisation de cette fonction présente dans la STL. Je suppose que le résultat est le même que lorsqu'on utilise un booléen a la suite d'un opérateur << sur cout (c'est à dire 0 pour false ou 1 pour true). Je me trompe peut être ceci dit.
Pour ce qui est du constructeur par copie je n'en ai pas définit. Voici le code de ma classe cNode:

cnode.h

Code:

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
#ifndef CNODE_H
#define CNODE_H
 
#include <list>
 
namespace huffman {
 
    class cNode {
    private:
        cNode * _leftSideNode;
        cNode * _rightSideNode;
        std::list<bool> * _code;
        unsigned char _caractere;
        unsigned int _frequence;
 
    protected:
        void addCodePart(const bool & codePart);
        void popCodepart();
 
    public:
        cNode(cNode * left = NULL, cNode * right = NULL, const unsigned char & caractere = 0, const unsigned int & frequence = 0);
        virtual ~cNode();
 
        inline cNode * getLeftSideNode() const { return _leftSideNode; };
        inline cNode * getRightSideNode() const { return _rightSideNode; };
        void setLeftSideNode(cNode * node);
        void setRightSideNode(cNode * node);
 
        std::list<bool> * getCode() const { return _code; };
 
        inline unsigned char getCaractere() const { return _caractere; };
        inline void setCaractere(const unsigned char & caractere) { _caractere = caractere; };
        inline unsigned int getFrequence() const { return _frequence; };
        inline void setFrequence(unsigned int & frequence) { _frequence = frequence; };
    };
};
 
 
 
#endif // CNODE_H

cnode.cpp

Code:

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
73
74
75
76
77
78
#include "cnode.h"
#include <cassert>
 
namespace huffman {
 
    cNode::cNode(cNode * left,
        cNode * right,
        const unsigned char & caractere,
        const unsigned int & frequence) :
        _leftSideNode(left),
        _rightSideNode(right),
        _caractere(caractere),
        _frequence(frequence)
    {
        if (_leftSideNode != NULL) {
            _leftSideNode->addCodePart(false);
        }
        if (_rightSideNode != NULL) {
            _rightSideNode->addCodePart(true);
        }
        _code = new std::list<bool>();
    }
 
    cNode::~cNode()
    {
        if (_leftSideNode != NULL) {
            delete _leftSideNode;
        }
        if (_rightSideNode != NULL) {
            delete _rightSideNode;
        }
        delete _code;
    }
 
    void cNode::addCodePart(const bool & codePart) {
        _code->push_front(codePart);
        if (_leftSideNode != NULL) {
            _leftSideNode->addCodePart(codePart);
        }
        if (_rightSideNode != NULL) {
            _rightSideNode->addCodePart(codePart);
        }
    }
 
    void cNode::setLeftSideNode(cNode * node) {
        if (_leftSideNode != NULL && _leftSideNode != node) {
            _leftSideNode->popCodepart();
        }
        if (_leftSideNode != node) {
            _leftSideNode = node;
        }
        if (_leftSideNode != NULL) {
            _leftSideNode->addCodePart(false);
        }
    }
 
    void cNode::setRightSideNode(cNode * node) {
        if (_rightSideNode != NULL && _rightSideNode != node) {
            _rightSideNode->popCodepart();
        }
        if (_rightSideNode != node) {
            _rightSideNode = node;
        }
        if (_rightSideNode != NULL) {
            _rightSideNode->addCodePart(true);
        }
    }
 
    void cNode::popCodepart() {
        _code->pop_front();
        if ( _leftSideNode != NULL ) {
            _rightSideNode->popCodepart();
        }
        if ( _rightSideNode != NULL ) {
            _leftSideNode->popCodepart();
        }
    }
}

04/04/2007, 09h34
Floréal

Citation:

Envoyé par alskaar

ca marchera mieux avec un iterator :

Code:

copy(code.begin(), code.end(), ostream_iterator<bool>(cout,"\n"));

Effectivement ça marche mieux comme ça j'ai du me planter en lisant la doc. Merci beaucoup (je n'avais pas lu ton message hier soir).