Potok Nienazwany

Witam,

Mam problem, bo nie wiem jak wysłać objekt typu WyrazenieHornera przez potok i go odebrac.

#include <iostream>
#include <new>
#include <cmath>
#include <sys/types.h>
#include <unistd.h>
#include <time.h>
#include <errno.h>
#include <sys/stat.h>
#include <stdio.h>



using namespace std;


class WyrazenieHornera 
{
 private :
  double wyn;
  double *tab;
  double x;
  int wielkoscTablicy;
 public :
  WyrazenieHornera()
  {
	
  }
  WyrazenieHornera(double *t, const double &xx, const int &wt)
  {
    wielkoscTablicy = wt;
    tab = new double[wt];
    for(int it = 0; it < wielkoscTablicy; ++it)
    {
         tab[0] = t[0];
    }
    x = xx;
    wyn = t[0];
    cout << "<---------------->tab[0]" << wyn << endl;
  }
 ~WyrazenieHornera()
 {
    delete[] tab;
 }
double getWynikDouble()
{
    return wyn;
}

void liczWyrazenie()
{
    wyn = (wyn * x) + tab[1];
}



};



int main()
{
double *tab; // tablica wspolczynikow wielomainu
int stopienWielomianu;
double wynik;
int wielkoscTablicy; //suma wspolczynikow wielomianu + wyraz wolny
double x;
//Zmienne dla potoków nie nazwanych
int deskplikmp[2]; //wysyla dane z macierzystego do potomnego
int deskplikpm[2];//wysyla dane z potomnego do macierzystego
double wynikTymczasowy;

if(pipe(deskplikmp) < 0) perror ("Pipe M->P nie utworzono \n");
if(pipe(deskplikpm) < 0) perror ("Pipe P->M nie utworzono \n");


    cout << "Podaj wielkosc wielomianu " << endl;
    cin >> stopienWielomianu;
    cout << "Podaj x " << endl;
    cin >> x;
    wielkoscTablicy = stopienWielomianu + 1;
    tab = new double[wielkoscTablicy];
	for(int i = 0; i < wielkoscTablicy; ++i)
	{
	     cout << " Podaj liczbe, ktroa stoi przy wielomianie stopnia " << (wielkoscTablicy - 1 - i) << endl;
	     cin >> tab[i];
	}	
    
WyrazenieHornera objHornera(tab, x, wielkoscTablicy);
WyrazenieHornera odebranieObjHornera;

//SWITCH początek
  pid_t pid;
  switch (pid = fork())
  {
	case -1:  /*obsluga bledu*/
	{	
	  perror ("nie udalo sie utworzyc prcesu potomnego \n");
	  //exit(1);
	  break; 
	}
	case 0:  /*powstanie procesu potomnego*/
	close(deskplikmp[1]); //zamyka do pisania	          
	close(deskplikpm[0]); //zamyka do czytania
        read(deskplikmp[0],&odebranieObjHornera ,sizeof(odebranieObjHornera));
        cout << "odebranieobjHorner " << odebranieObjHornera.getWynikDouble() << endl;
	   break;  
	  
	{

	}
	default:    /*proces macierzysty*/
	{
	     
	  close(deskplikmp[0]); //zamyka do czytania
	  printf("\nWyslalrem obj do potomnego");
	  write(deskplikmp[1],&objHornera,sizeof(objHornera));
	  
//----------------------------------------------------------------=======================
	  
	  
	  //if (wait(NULL) == -1) perror("wait error");
	  break;
	}  
 }
//Koniec Switcha 


	
return 0;
}

 

Bez serializacji nie da rady. Musisz swój obiekt zamienić na taki format, z którego jesteś w stanie go potem odtworzyć. Zwykłe jest to jakiś format binarny albo tekstowy. W Twoim przypadku nie możesz po prostu skopiować zawartości binarnej struktury, bo wskaźniki w niej zawarte będą wskazywać na śmieci w pamięci.

double wyn;
size_t wielkoscTablicy;
double *tab;
double x;

Zapisz to tak:
12.2-4:0,1,2,3-17.5;

Potem przy odczytywaniu:

1. splitujesz po myslniki.
2. konwersja 1 i 3 na double i zapisanie do wyn/x.
3. split po dwukropku
4. zapisanie 4ki do wielkosc...
5. utworzenie tablicy.
6. split po przecinku
7. wypelnienie tablicy

a jak to zrobić??
Boost.Serialize jest dość przystępnym i potężnym rozwiązaniem. Jak nie chcesz Boosta, możesz zrobić własne funkcje fromString i toString lub przeładować operatory >> i << dla std::istream i std::ostream odpowiednio.

Jeśli chodzi o samą implementację, to nie używałbym formy binarnej, mimo, że dla tego samego kompilatora powinno być to bezpieczne. Pola o stałej długości zapisz na początku w zdefiniowanej kolejności, a następnie wypisz wielkość tablicy i potem jej zawartość. Wczytuj odwrotnie.

#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <algorithm>
#include <iterator>
using namespace std;

string to_string(double x) {
	stringstream ss;
	ss << x;
	return ss.str();
}

template<class T>
T fromString(string s) {
	T result;
	stringstream ss(s);
	ss >> result;
	return result;
}

std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
    std::stringstream ss(s);
    std::string item;
    while (std::getline(ss, item, delim)) {
        elems.push_back(item);
    }
    return elems;
}


std::vector<std::string> split(const std::string &s, char delim) {
    std::vector<std::string> elems;
    split(s, delim, elems);
    return elems;

}

void displ(vector<string> el) {
	cout << "\n\n";
	copy(el.begin(), el.end(), ostream_iterator<string>(cout, "\t"));
	cout << "\n\n";
}

class Foo {
    double wyn;
    size_t wielkoscTablicy;
    double *tab;
    double x;
    
public:
    Foo(double wn, double x, size_t w):
        wyn(wn),
        x(x),
        wielkoscTablicy(w)
    {
        tab = new double[w];
        
        for(size_t i = 0; i < w; ++i) {
            tab[i] = i*2;
      	}
    }
 
    string serialize() {
        string tab = to_string(wielkoscTablicy) + ":";
        for(size_t i = 0; i < wielkoscTablicy; ++i) {
            tab += to_string(this->tab[i]) + ",";
        }
    
    	stringstream out;	
        out << wyn << "-" << x << "-" << tab << "\n";
	return out.str();
    }

    void deserialize(string s) {
	    vector<string> all = split(s, '-');
	    displ(all);
	    this->wyn = fromString<double>(all[0]);
	    this->x = fromString<double>(all[1]);

	    vector<string> alltab = split(all[2], ':');
	    this->wielkoscTablicy = fromString<size_t>(alltab[0]);
	    displ(alltab);
	    vector<string> tab = split(alltab[1], ',');
	    displ(tab);
	    if(this->tab) delete[] this->tab;
	    this->tab = new double[this->wielkoscTablicy];
	    for(size_t i = 0; i < this->wielkoscTablicy; ++i) {

	    	this->tab[i] = fromString<double>(tab[i]);
	    }
    }
};
 
int main() {
    Foo f(10, 12.5, 5);
    string fs = f.serialize();
    f.deserialize(fs);
    cout << fs << endl;
    return 0;
}

http://ideone.com/qkoeS3