proggen.org

Code: Alles auswählen

<Rückgabewert> operator += (<AndererTyp> <anderesObjekt>) 

Code: Alles auswählen

#include <iostream>


struct MeineKlasse 
{
    int val;

    // konstruktor, objekt wir mit int initialisiert
    MeineKlasse(int _val)
     : val(_val)
    {}

    // ueberlade den += operator
    MeineKlasse& operator += (int other)
    { val += other; return *this; }
};

// ueberlade den stream operator fuer ostream, damit wir cout benutzen koennen
std::ostream& operator << (std::ostream& os, const MeineKlasse& k)
{ return os<<k.val; }

int main()
{
    MeineKlasse mein_objekt(5);        
    std::cout<<"mein_objekt ist "<<mein_objekt<<'\n'; // verwende stream operator

    // verwende += operator
    mein_objekt += 22;

    std::cout<<"mein_objekt ist jetzt "<<mein_objekt<<'\n';
    return 0;
};

Code: Alles auswählen

static hexstring^ operator +=(hexstring^ a);

Code: Alles auswählen

error C2805: Binärer Operator '+=' hat zu wenig Parameter

Code: Alles auswählen

hexstring^ operator =(int data);

Code: Alles auswählen

error C2440: '=': 'int' kann nicht in 'hexstring ^' konvertiert werden

Code: Alles auswählen

class Fraction
{
  private:
    int Numerator;
    int Denominator;
  public:
    Fraction( int num, int den ) : Numerator( num ), Denominator( den ) {}
    Fraction & operator *=( Fraction & rhs );
};

Fraction & Fraction::operator *=( Fraction & rhs )
{
  Numerator   *= rhs.Numerator;
  Denominator *= rhs.Denominator;
  return *this;
}

Code: Alles auswählen

#include <iostream>


struct MeineKlasse 
{
    int val;

    // konstruktor, objekt wir mit int initialisiert
    MeineKlasse(int _val)
     : val(_val)
    { std::cout<<"Constructed\n";}

    // ueberlade den += operator
    MeineKlasse& operator += (int other)
    { val += other; return *this; }
        
    ~MeineKlasse()
    { std::cout<<"Destructed\n";}
};

// ueberlade den stream operator fuer ostream, damit wir cout benutzen koennen
std::ostream& operator << (std::ostream& os, const MeineKlasse& k)
{ return os<<k.val; }

int main()
{
    MeineKlasse mein_objekt = 5;        
    std::cout<<"mein_objekt ist "<<mein_objekt<<'\n'; // verwende stream operator

    // hier wird das alte objekt zerstört, ein neues erstellt und dann
    // zugewiesen
    mein_objekt = 11;

    std::cout<<"mein_objekt ist jetzt "<<mein_objekt<<'\n';
    return 0;
};

Code: Alles auswählen

//hextsring.h
//stellt einen hexstring zur verfügung

#ifndef HEXSTRING_H
#define HEXSTRING_H

ref class hexstring
{
private:
	System::String^ hex;
public:

	System::String^ get() {
		return hex;
	};

	property System::String^ default[int] {
		System::String^ get(int idx);
		//void set(int idx, hexstring^ data);
		//void set(int idx, int data);
		//void set(int idx, char data);
		void set(int idx, System::String^ binärdata);
	}

	void set(int data);
	void set(System::String^ data);

	hexstring(int data);
	hexstring(System::String^ binärdata);
	
	void add_data(int data);
	void add_data(System::String^ data);

	static hexstring^ operator +(hexstring^ a, hexstring^ b);
	static hexstring^ operator +(hexstring^ a, int data);
	static hexstring^ operator +(hexstring^ a, System::String^ binärdata);

	hexstring^ operator =(const char *data);
	hexstring^ operator =(hexstring^ a);
	hexstring^ operator =(int data);
	hexstring^ operator =(System::String^ binärdata);
	hexstring^ operator =(wchar_t *data);

	hexstring^ operator +=(hexstring^ a);
	hexstring^ operator +=(int data);
	hexstring^ operator +=(System::String^ binärdata);

	static bool operator ==(hexstring^ a, hexstring^ b);
	static bool operator ==(hexstring^ a, int data);
	static bool operator ==(hexstring^ a, System::String^ binärdata);
};
#endif

Code: Alles auswählen

//hexstring.cpp
//Definiert ale funktionen aus hextsring.h

#include "stdafx.h"
#include "hexstring.h"

using namespace System;


//
///////////////////////////////////////////
//Memberfunktionen

wchar_t tohex(wchar_t number)
{
	if(number>15)
	{
		//MessageBox::Show("Nummer zu groß", "Hinweis");
		return 0;
	}
	else 
	{
		switch(number){
			case 0: return '0';
			case 1: return '1';
			case 2: return '2';
			case 3: return '3';
			case 4: return '4';
			case 5: return '5';
			case 6: return '6';
			case 7: return '7';
			case 8: return '8';
			case 9: return '9';
			case 10: return 'A';
			case 11: return 'B';
			case 12: return 'C';
			case 13: return 'D';
			case 14: return 'E';
			case 15: return 'F';
		}
	}
	return 'Z';
}

int toint(wchar_t number) 
{
	switch(number)
	{
		case '0': return 0;
		case '1': return 1;
		case '2': return 2;
		case '3': return 3;
		case '4': return 4;
		case '5': return 5;
		case '6': return 6;
		case '7': return 7;
		case '8': return 8;
		case '9': return 9;
		case 'A': return 10;
		case 'B': return 11;
		case 'C': return 12;
		case 'D': return 13;
		case 'E': return 14;
		case 'F': return 15;
	}
	return 0;
}
		
System::String^ chartohex(unsigned char a)
{
	String^ result;
	result=tohex(a/16).ToString();
	result+=tohex(a%16).ToString();
	return result;
}

String^ inttohex(unsigned long i)
{
	String^ result="";
	unsigned long tmp = i;
	for(int i = 7; i > 0; i--)
	{
		result+=tohex(tmp/(16^i));	//Wie häufig kommt 16î vor?
		tmp=(tmp%16^i);				//Den rest der Division speichern
	}
	result+=tohex(tmp);				//Den rest in result speichern
	return result;
}

String^ stringtohex(System::String^ binärdata)
{
	String^ tmp;
	for(int i=0; i < binärdata->Length;i++)
	{
		tmp+=chartohex(binärdata[i]);
	}
	return tmp;
}

int hextoint(String^ hexstring)
{
	int tmp=0;
	for(int i=0; i<hexstring->Length; i+=2)
	{
		tmp+=(toint(hexstring[i]<<4)+toint(hexstring[i+1]));
	}
	return tmp;
}

//
///////////////////////////////////////////////////
//Konstruktor

hexstring::hexstring(int data)
{
   hex = inttohex(data);
}

hexstring::hexstring(String^ binärdata)
{
	hex = stringtohex(binärdata);
}

//
/////////////////////////////////////////////////
//Funktionen zum Manipulieren des Inhaltes des Hexstrings

void hexstring::add_data(int data)
{
	hex += inttohex(data);
}

void hexstring::add_data(String^ binärdata)
{
	hex+=stringtohex(binärdata);
}


void hexstring::set(int data)
{
	hex = inttohex(data);
}

void hexstring::set(String ^data)
{
	hex = stringtohex(data);
}

//
/////////////////////////////////////////////////
//Indexer:

String^ hexstring::default::get(int idx)			//gibt das Zeichenpaar für das Byte an stelle idx aus
{
	if((idx*2)>hex->Length) return "00";
	else return hex->Substring(idx*2, 2);
}

//void hexstring::default::set(int idx, hexstring^ data)
//{
//	hex->Replace(hex->Substring(idx*2, data->hex->Length), data);
//}
//
//void hexstring::default::set(int idx, int data)
//{
//	hex->Replace(hex->Substring(idx*2, 8), inttohex(data));
//}
//
//void hexstring::default::set(int idx, char data)
//{
//	hex->Replace(hex->Substring(idx*2,2), chartohex(data));
//}

void hexstring::default::set(int idx, String^ binärdata)
{
	hex->Replace(hex->Substring(idx*2, binärdata->Length), stringtohex(binärdata));
}

//
/////////////////////////////////////////////////
//Operatordefinitionen

//+:

hexstring^ hexstring::operator +(hexstring ^a, hexstring ^b)
{
	return gcnew hexstring(a->hex + b->hex);
}

hexstring^ hexstring::operator +(hexstring ^a, int data)
{
	return gcnew hexstring(a->hex + inttohex(data));
}
hexstring^ hexstring::operator +(hexstring ^a, System::String ^binärdata)
{
	return gcnew hexstring(a->hex + stringtohex(binärdata));
}

//
//////////////////////////////////////////
//+=:

hexstring^ hexstring::operator +=(hexstring ^a)
{
	hex+=a->hex;
	return this;
}

hexstring^ hexstring::operator +=(int data)
{
	hex += inttohex(data);
	return this;
}

hexstring^ hexstring::operator +=(System::String ^binärdata)
{
	hex += stringtohex(binärdata);
	return this;
}

//
//////////////////////////////////////////
//=:

hexstring^ hexstring::operator =(hexstring ^a)
{
	hex = a->hex;
	return this;
}

hexstring^ hexstring::operator =(int data)
{
	hex = inttohex(data);
	return this;
}

hexstring^ hexstring::operator =(String ^binärdata)
{
	hex = stringtohex(binärdata);
	return this;
}

hexstring^ hexstring::operator =(wchar_t *data)
{
	hex = Convert::ToString(*data);
	return this;
}

hexstring^ hexstring::operator =(const char *data)
{
	hex = Convert::ToString(*data);
	return this;
}

//
//////////////////////////////////////////
//==:

bool hexstring::operator ==(hexstring^ a, hexstring^ b)
{
	if(a->hex == b->hex) return true;
	else return false;
	return false;
}

bool hexstring::operator ==(hexstring^ a, int data)
{
	if(a->hex == inttohex(data)) return true;
	else return false;
	return false;
}

bool hexstring::operator ==(hexstring^ a, String^ binärdata)
{
	if(a->hex == stringtohex(binärdata))return true;
	else return false;
	return false;
}