Normalize a class.

See version :

Pas de dépendances

Download :

#include <iostream>
#include <string.h>

class Fstring
{
protected:
    char* p;
public:
    //Fstring();
    Fstring(char* inp);
    friend std::ostream& operator<<(std::ostream&,const Fstring&);
    //~Fstring();
    //Fstring(const Fstring&);
    //Fstring& operator=(const Fstring&);
};

/*Fstring::Fstring()
{
    p = new char[1];
    p[0]='\0';
    std::cout << "construction de base adresse " << (int)p << std::endl;
}*/

Fstring::Fstring(char* inp)
{
    p = new char[strlen(inp)+1];
    strcpy(p,inp);
    std::cout << "construction adresse " << (int)p << std::endl;
}

std::ostream& operator<<(std::ostream& os,const Fstring& s)
{
    os << s.p;
    return os;
}

/*Fstring::~Fstring()
{
    std::cout << "destruction adresse " << (int)p << std::endl;
    delete [] p;
}*/

/*Fstring::Fstring(const Fstring& in)
{
    p = new char[strlen(in.p)+1];
    strcpy(p,in.p);
    std::cout << "construction par recopie adresse " << (int)p << std::endl;
}

Fstring& Fstring::operator=(const Fstring& in)
{
    std::cout << "Assign egal "<< std::endl;    
    if (&in!=this)
    {
        std::cout << "destruction dans egal adresse " << (int)p << std::endl;        
        delete [] p;
        p = new char[strlen(in.p)+1];
        strcpy(p,in.p);
        std::cout << "construction dans egal adresse " << (int)p << std::endl;
    }
    return *this;
}
*/

int main()
{
    Fstring f("plouf");
    std::cout << f << std::endl;
    Fstring g(f);
    //Fstring h;
    //h = g;
    std::cout << f << std::endl;
    std::cout << g << std::endl;
    //std::cout << h << std::endl;
    //g = g;
    std::cout << "programme fini" << std::endl;
    return 0;
}

	No explanations yet.