Opeator overloading.....

Jeg ved ikke om det er muligt, men jeg kan se at << operatoren for ostream er defineret for en streambuf klasse. Kan du ikke nedarve din Streng klasse fra den og på den måde udskrive til en ostream?

Ved ikke lige om det kan lade sig gøre da jeg er meget ny i C/C++ verden men vil da lige kigge på det...

Spørgsmålet er nok mere om det er nødvendigt???

Smid følgende i bunden af din header fil:

ostream & operator<<(ostream & stream, Streng & str);

..og implementér den således:

ostream & operator<<(ostream & stream, Streng & str) {
  stream << str.ShowStr();
  return stream;
}

Det burde gøre det.

Tak for hjælp selvom det kke var til meget...

.... for jeg kan heller ikke få dit forslag til at virke overhovedet på nogen måde... Mener det er muligt der er en fejl i din erklæring...

Jeg graver lige lidt mere på nettet... Det skal lade sig gøre, det burde det...
Men hvad jeg er også helt grøn, rom blev jo ikke bygget på uge.

#include <iostream>

using namespace std;

class Streng {
    private:
        char * str;
    public:
        Streng(char * strPtr) : str(strPtr) {}
        char * ShowStr() { return str; }
};

ostream & operator << (ostream & stream, Streng & str) {
    stream << str.ShowStr();
    return stream;
}

int main (int argc, char ** argv) {
    Streng str("Hello, World");

    cout << "Writing out my string: " << str << endl;

    return 0;
}

Tak for hjælpen Robert...

Men jeg har lige lidt yderligere spørgsmål ang. denne operator over load...

jeg kan sagtens få Roberts eksempel til at virke, endvidere med en lille ændring:

Jeg fjerner ShowStr funktionen og tilføjer en friend funktion der bevirker jeg kan få direkte adgang til de private variabler i klassen.

Er som følger: Str.h

class Streng {
    private:
        char* str;
    public:
        Streng( char* strPtr ) : str( strPtr ) {}
		friend ostream& operator << ( ostream&, const Streng& );
};

ostream& operator << (ostream& outStream, const Streng& rhs)
{
    outStream << rhs.str;
    return outStream;
}

Oventående kode virker fint, lige efter bogen.

Så har jeg min egen Str.h hvor jeg har tilføjet mit operator overload << til klassen ligesom eksemplet ovenfor...

Str.h

class Streng
{
private:
	// Declaring variables
	char*	str;
	int		length;
	
	// Private help constructor - Used by copy constructor
	Streng( int );

public:
	// Constructors and destructor
	Streng ( void );
	Streng ( const char* const );
	Streng ( const Streng& );		// Copy constructor
	~Streng( void );				// Destructor

	// Public functions inline
	int			StrLen	( void )	const { return length; }
	const char*	ShowStr	( void )	const { return str; }

	// Operator overload
	friend	ostream& operator << ( ostream&, const Streng& );	
			char&	 operator [] ( int );
			char	 operator [] ( int ) const;
			Streng	 operator +  ( const Streng& );
			void	 operator += ( const Streng& );
			Streng&	 operator =  ( const Streng& );
};

ostream& operator << ( ostream& stream, Streng& rhs )
{
	stream << rhs.str;
    return stream;
}

Men det virker ikke og jeg forstår det ikke for jeg syntes jeg har implementeret det ligesom det er implementeret i i eksemplet ovenfor dette.

Jeg har også prøvet at lege med at have selve definitionen til operator overload i min Str.cpp men det giver også knuder...

ER jeg bare dum og blind så jeg ikke kan se en syntax fejl eller hvad er der i vejen???

Hvis i er interesseret i hele koden så mail mig på kent.s.olsen@live.dk eller tilføj mig til MSN via restless@live.dk.

Jeg sender gerne mine filer så i kan se på det samlet.

Hvad siger compileren ?
Post bare hele koden til Str.h og Str.cpp.

Str.h:

#pragma once

#define NULL 0

class Streng
{
private:
	// Declaring variables
	char*	str;
	int		length;
	
	// Private help constructor - Used by copy constructor
	Streng( int );

public:
	// Constructors and destructor
	Streng ( void );
	Streng ( const char* const );
	Streng ( const Streng& );		// Copy constructor
	~Streng( void );				// Destructor

	// Public functions inline
	int			StrLen	( void )	const { return length; }
	const char*	ShowStr	( void )	const { return str; }

	// Operator overload
	//friend	ostream& operator << ( ostream&, const Streng& );	
			char&	 operator [] ( int );
			char	 operator [] ( int ) const;
			Streng	 operator +  ( const Streng& );
			void	 operator += ( const Streng& );
			Streng&	 operator =  ( const Streng& );
};

//ostream& operator << ( ostream& stream, Streng& rhs )
//{
//stream << rhs.str;
//return stream;
//}

Str.cpp:

#include "Str.h"

// Standard constructor
Streng::Streng( void )
{
	str = new char[1];
	str[0] = NULL;
	length = 0;
}

/*	Private help constructor
	used by object to fill a
	string(Streng) with NULL values.
	Used by copy constructor  */
Streng::Streng( int len )
{
	str = new char[len + 1];

	for (int i = 0; i <= len; i++) str[i] = NULL;
	length = len;
}

// Public constructors
Streng::Streng( const char* const cStr )
{
	length = 0;
	while (*(cStr+length)) length++;
	//while (cStr[length]) length++;
	
	str = new char[length + 1];

	for (int i = 0; i < length; i++) str[i] = cStr[i];
	str[length] = NULL;
}

Streng::Streng( const Streng& rhs )  // Copy constructor
{
	length = rhs.StrLen();
	str = new char[length + 1];
	
	for (int i = 0; i < length; i++) str[i] = rhs[i];
	str[length] = NULL;
}

// Destructor
Streng::~Streng( void )
{
	delete [] str;
	length = 0;
}

// Operator overload
char& Streng::operator [](int n)
{
	if (n > length)
		return(str[length - 1]);
	else
		return(str[n]);
}

char Streng::operator [](int n) const
{
	if (n > length)
		return(str[length - 1]);
	else
		return(str[n]);
}

Streng Streng::operator +(const Streng &rhs)
{
	int totalLen = length + rhs.StrLen();
	int i, j;

	Streng temp(totalLen);

	for (i = 0; i < length; i++) temp[i] = str[i];
	for (j = 0; j < rhs.StrLen(); j++, i++) temp[i] = rhs[i - length];

	temp[totalLen] = NULL;

	return(temp);
}

void Streng::operator +=(const Streng &rhs)
{
	int rhsLen = rhs.StrLen();
	int totalLen = length + rhsLen;
	int i, j;

	Streng temp(totalLen);

	for (i = 0; i < length; i++) temp[i] = str[i];
	for (j = 0; j < rhs.StrLen(); j++, i++) temp[i] = rhs[i - length];
	temp[totalLen] = NULL;

	*this = temp;

	return;
}

Streng& Streng::operator =(const Streng &rhs)
{
	if (this == &rhs) return(*this);

	delete [] str;
	length = rhs.StrLen();
	str = new char[length + 1];

	int i;
	for (i = 0; i < length; i++) str[i] = rhs[i];
	str[length] = NULL;

	return(*this);
}

main.cpp:

#include <iostream>
using namespace std;

#include "Str.h"

int main( void )
{
	Streng bob("Hej med dig :) ");
	Streng ib, bo, ny;

	ib = "Dette er en streng-type!!! ";
	bo = "HIGH FIVE!!! :)";

	ny = bob + ib;
	ny += bo;

	cout << ny.ShowStr() << endl;
	//cout << ny << endl;

	cout << endl;
	cout << "Strengen er " << ny.StrLen() << " tegn lang." << endl;
	cout << endl;

	for( int i = 0; ny[i]; i++ ) if( !(i % 2) ) ny[i] = '1'; else ny[i] = '0';

	cout << ny.ShowStr() << endl;
	//cout << ny << endl;

	cout << endl;

	system("PAUSE");

	return(0);
}

Jeg laver et include i main.cpp til iostream før jeg inkluderer Str.h.... Sådan at den skulle være istand til at kende ostream klassen uden at inkludere den i str.h

Jeg fjernede din '#define NULL 0' fra Str.h og inkluderede <iostream> i Str.cpp, så fik jeg følgende:

robert@robert-laptop:~/code$ g++ -o test main.cpp Str.cpp 
robert@robert-laptop:~/code$ ./test 
Hej med dig :) Dette er en streng-type!!! HIGH FIVE!!! :)

Strengen er 57 tegn lang.

101010101010101010101010101010101010101010101010101010101

robert@robert-laptop:~/code$

Taxi... Havde set mig blind på det men nu virker det som det skal.