Metoda z argumentem w postaci fstream

Question

Hej,

mam problem z napisaniem metody która przyjmowała by jako parametr obiekt fstream. Metoda ma zapisywać do pliku dane z klasy.

void abstr_emp::WriteAll(std::fstream& file) const
{
    file << fname;
}

Tego typu zabiegi przynosza odpowiedz kompilatora w postaci komunikatu:

error: no match for 'operator<<' (operand types are 'std::fstream {aka std::basic_fstream<char>}' and 'const char [5]')|

Próbowałem rożnych wersji i zawsze jest bład. Nie wiem jak to mozna inaczej zrobic. Dodam tez ze jest to funkcja wirtualna i inne jej wersje umieszam w pozostalych klasach.

Pisze to w Code Blocsie

Moze ktoś wie jak napisac taka metode, byłbym wdzieczny za pomoc.

Answer 1

Użyj metody write: http://en.cppreference.com/w/cpp/io/basic_ostream/write

btw. Dlaczego używasz tablicy charów zamiast std::stringa?

Comments

Do przechowywania zmiennych używam string nie tablicy charów, niestety write tez nie działa. Właściwe cokolwiek probuje zrobic z "file" generuje bład.
 

void abstr_emp::WriteAll(std::fstream& file) const
{
    file.open("plik.txt");

}

|error: invalid use of incomplete type 'std::fstream {aka class std::basic_fstream<char>}'|

---

Podaj więcej kodu. Może nie masz dołączonej biblioteki <string>?

---

#ifndef ABST_EMP_H
#define ABST_EMP_H

#include <iostream>
#include <string>

class abstr_emp
{
private:
    std::string fname;
    std::string lname;
    std::string job;
public:
    abstr_emp();
    abstr_emp(const std::string & fn,const std::string & ln,
             const std::string & j);
    virtual void ShowAll() const;
    virtual void SetAll();
    virtual void WriteAll(std::fstream& file) const;
    friend std::ostream & operator<<(std::ostream & os, const abstr_emp & e);
    virtual ~abstr_emp() = 0;
};

class employee
: public abstr_emp
{
public:
    employee();
    employee(const std::string & fn,const std::string & ln,
             const std::string & j );
    virtual void ShowAll()const;
    virtual void WriteAll(std::fstream& file) const;
    virtual void SetAll();
};

class manager
:virtual public abstr_emp
{
private:
    int inchargeof;
protected:
    int InCharge0f()const {return inchargeof;}
    int & InCharge0f() {return inchargeof;}
public:
    manager();
    manager(const std::string & fn,const std::string & ln,
             const std::string & j,int ico = 0);
    manager(const abstr_emp & e,int ico);
    manager(const manager & m);
    virtual void ShowAll()const;
    virtual void WriteAll(std::fstream& file) const;
    virtual void SetAll();
};

class fink
:virtual public abstr_emp
{
private:
    std::string reportsto;
protected:
    const std::string ReportsTo()const {return reportsto;}
    std::string & ReportsTo() {return reportsto;}
public:
    fink();
    fink(const std::string & fn,const std::string & ln,
             const std::string & j,const std::string & rpo);
    fink(const abstr_emp & e, const std::string & rpo);
    fink(const fink & e);
    virtual void ShowAll() const;
    virtual void WriteAll(std::fstream& file) const;
    virtual void SetAll();
};

class highfink
: public manager, public fink
{
 public:
     highfink();
     highfink(const std::string & fn,const std::string & ln,
             const std::string & j,const std::string & rpo,
             int ico);
     highfink(const abstr_emp & m,const std::string & rpo,int ico);
     highfink(const fink & m, int ico);
     highfink(const manager & m, const std::string rpo);
     highfink (const highfink & h);
     virtual void ShowAll() const;
     virtual void WriteAll(std::fstream& file) const;
     virtual void SetAll();
};
#endif // ABST_EMP_H


i plik cpp

 

#include "abst_emp.h"



//abstr_emp

abstr_emp::abstr_emp()
{
    fname = "nie podano";
    lname = "nie podano";
    job   = "nie podano";
}
abstr_emp::abstr_emp(const std::string & fn,const std::string & ln,
            const std::string & j)
{
    fname = fn;
    lname = ln;
    job   = j;
}
abstr_emp::~abstr_emp() = default;


void abstr_emp::ShowAll() const
{
    std::cout<<fname<<" "<<lname<<" "<<job;
}

void abstr_emp::WriteAll(std::fstream& file) const
{
    file << fname;

}

void abstr_emp::SetAll()
{
   std::cout<<"Podaj imie: ";
   std::cin>>fname;
   std::cout<<"Podaj nazwisko: ";
   std::cin>>lname;
   std::cout<<"Podaj zawow: ";
   std::cin>>job;
}


std::ostream & operator<<(std::ostream & os, const abstr_emp & e)
{
    os << e.fname <<" "<<e.lname;
    return os;
}

// employee

employee::employee()
:abstr_emp()
{
}
employee::employee(const std::string & fn,const std::string & ln,
                    const std::string & j )
:abstr_emp(fn,ln,j)
{
}

void employee::ShowAll()const
{
    abstr_emp::ShowAll();
}

void employee::WriteAll(std::fstream& file) const
{
abstr_emp::WriteAll();


}

void employee::SetAll()
{
    abstr_emp::SetAll();
}

//manager

manager::manager()
:abstr_emp()
{
    inchargeof = 0;
}

manager::manager(const std::string & fn,const std::string & ln,
             const std::string & j,int ico )
:abstr_emp(fn,ln,j)
{
    inchargeof = ico;
}
manager::manager(const abstr_emp & e,int ico)
:abstr_emp(e)
{
    inchargeof = ico;
}
manager::manager(const manager & m)
:abstr_emp(m)
{
   inchargeof=m.inchargeof;
}

void manager::ShowAll()const
{
    abstr_emp::ShowAll();
    std::cout<<" "<<"zarzadzanych: "<<inchargeof;
}

void manager::WriteAll(std::fstream& file) const
{
abstr_emp::WriteAll();


}

void manager::SetAll()
{
    abstr_emp::SetAll();
    std::cout<<"Podaj liczbe zarzadzanych obiektow: ";
    std::cin>>inchargeof;
}

//fink

fink::fink()
:abstr_emp()
{
    reportsto = "nie podano";
}

fink::fink(const std::string & fn,const std::string & ln,
             const std::string & j,const std::string & rpo)
:abstr_emp(fn,ln,j)
{
   reportsto = rpo;
}

fink::fink(const abstr_emp & e, const std::string & rpo)
:abstr_emp(e)
{
   reportsto = rpo;
}
fink::fink(const fink & e)
{
  *this = e;
}
void fink::ShowAll() const
{
    abstr_emp::ShowAll();
    std::cout<<" adresat: "<<reportsto;
}

void fink::WriteAll(std::fstream& file) const
{

abstr_emp::WriteAll();

}

void fink::SetAll()
{
    abstr_emp::SetAll();
    std::cout<< "Podaj adresata: ";
    std::cin>>reportsto;
}

// highfink

highfink::highfink()
:manager(),fink(),abstr_emp()
{
}

highfink::highfink(const std::string & fn,const std::string & ln,
             const std::string & j,const std::string & rpo,
             int ico)
:manager(fn,ln,j,ico),fink(fn,ln,j,rpo),abstr_emp(fn,ln,j)
{
}

highfink::highfink(const abstr_emp & m,const std::string & rpo,int ico)
:manager(m,ico),fink(m,rpo),abstr_emp(m)
{
}

highfink::highfink(const fink & m, int ico)
:manager(m,ico),fink(m),abstr_emp(m)
{

}

highfink::highfink(const manager & m, const std::string rpo)
:manager(m),fink(m,rpo),abstr_emp(m)
{

}
highfink::highfink (const highfink & h)
{
    *this = h;
}
void highfink::ShowAll() const
{
    manager::ShowAll();
    std::cout <<" raportuje do: " << ReportsTo();
}

void highfink::WriteAll(std::fstream& file) const
{



}

void highfink::SetAll()
{
    manager::SetAll();
    std::cout<<"Podaj adresata: ";
    std::cin >> ReportsTo();
}

 

 

Dobra przepraszam za zamieszanie, wystarczyło dodać biblioteke fstream ... nie wiem dlaczego jej nie dodałem.