Aide pour trouver m'erreur dans mon programme

Bonjour,
quelqu'un peux m'aider je trouve pas l'erreur



//#include"context.h"
#include <string>
#include <vector>
#include <iostream>

no match for 'operator<<' in 'std::operator<< <std::char_traits<char> >((* &(& std::operator<< <std::char_traits<char> >((* & tempout.std::basic_ofstream<char>::<anonymous>), ((const char*)"Node ")))->std::basic_ostream<_CharT, _Traits>::operator<< <char, std::char_traits<char> >(i.__gnu_cxx::__normal_iterator<_Iterator, _Container>::operator-><Lattice<std::pair<std::vector<int>, std:



#include<fstream>

#include<stdlib.h>
#include <algorithm>
#include<stdio.h>
#include <set>
#include <utility>
#include <functional>
#include <strstream>
#include<typeinfo>
#include"neighbors.h"


//using namespace std;
class Context;


template<typename N>


class Lattice{


public:

int count;
typedef std::pair<std::vector<int>, std::vector<int> > Concept;

struct Node {

int index;

typedef std::pair<std::vector<int>, std::vector<int> > Concept;
// Concept c;

Node() {};
Node(const N& con, int i) : c(con), index(i) {};

N c;


bool operator== (const Node& n) const { return c.first == n.c.first; }
std::pair<std::vector<int>,std::vector<int> > lowerUpperNeighbors;} ;


std::vector<Node> latticeSet;

int last_position_cached;

bool was_insert_called;



Lattice() : count(0), last_position_cached(0), was_insert_called(false) {}

friend ostream& operator<< ( std::ostream& out, const Concept &c){

out << "{"; if (c.first.size()!=0) {
for(std::vector<int>::const_iterator j = c.first.begin();
j < c.first.end() - 1; ++j) out << *j << ", "; out << *(c.first.end() - 1); }
out << "}, {"; if (c.second.size()!=0) {
for(vector<int>::const_iterator j = c.second.begin(); j < c.second.end() - 1; ++j) out << *j << ", "; out << *(c.second.end() - 1); } out << "}";
return out;
}



bool insertLookup(const N& x, const N& c) {
std::vector<Node> latticeSet;

typename vector<Node>::iterator x_pos = find(latticeSet.begin(), latticeSet.end(), Node(x, count));
if(x_pos == latticeSet.end()) {
latticeSet.push_back(Node(x, count++));
x_pos = latticeSet.end() - 1; }
typename vector<Node>::iterator c_pos;
if(was_insert_called && !(latticeSet[last_position_cached].c.first == c.first)) {
c_pos = find(latticeSet.begin(), latticeSet.end(), Node(c, count));
if(c_pos == latticeSet.end()) {
return false; } }
else
c_pos = latticeSet.begin() + last_position_cached;
x_pos->lowerUpperNeighbors.first.push_back(c_pos->index);
c_pos->lowerUpperNeighbors.second.push_back(x_pos->index);
return true;
}



bool insert(const N& c) {

latticeSet.push_back(Node(c, count++)); was_insert_called = true; return true; }


bool next(const N& c, N& output) {


typename vector<Node>::iterator pos = find(latticeSet.begin(), latticeSet.end(), Node(c, 0));
if(pos == latticeSet.end() || ++pos == latticeSet.end())
return false; output = pos->c;
last_position_cached = pos - latticeSet.begin();
return true; }



void printGraphplaceInput(ofstream& out, int flag = 0) {

ofstream tempout("explain.graph");


for(typename std::vector<Node>::iterator i = latticeSet.begin(); i!=latticeSet.end();++i) {

tempout<<"Node " << i->index << ": " <<i->c<<endl;//c'est la ligne d'erreur



out << "(";
if(flag == 0) {
out<<i->c;}
else
if(flag == 1) {
out << i->index; }

out << ") " << i->index << " node" << endl;
for(typename vector<int>::iterator j = i->lowerUpperNeighbors.second.begin(); j < i->lowerUpperNeighbors.second.end();++j)
out << *j << " " << i->index << " edge" << endl; }};


unsigned int getLatticeSize() {

return latticeSet.size();}



void LatticeAlgorithm(const Context& GMI, Lattice<Concept>& L) {
vector<int> temp; Concept c;
GMI.objDPrime((const vector<int>&) temp, c.first);
GMI.objPrime((const vector<int>&) temp, c.second);
L.insert(c);
neighbors n;
vector<Concept> neighborSet;
do {
n.Neighbors(c, GMI, neighborSet);
for(vector<Concept>::const_iterator x = neighborSet.begin(); x < neighborSet.end(); ++x) { L.insertLookup(*x, c); } }
while(L.next(c, c));
}



};