ich habe eine Klasse gechrieben in der ich den &-Operator überladen möchte:

BinaryInt BinaryInt::operator&(const BinaryInt bi)
{
	int size	= MAX(strlen(cIntBin), strlen(bi.cIntBin)) + 1;		// + 1: Null Terminator
	int minsize = MIN(strlen(cIntBin), strlen(bi.cIntBin));

	char* res = new char[size];

	for (int i=0; i < minsize; ++i)
		res[i] = (cIntBin[i] == '1' && bi.cIntBin[i] == '1') ? '1' : '0';

	res[minsize] = '\0';

	delete [] cIntBin;            //  HEAP CORRUPTION #135!!
	cIntBin = new char[strlen(res)];
	strcpy(cIntBin, res);
	delete [] res;

	return *this;
}

cIntBin wurde über den Heap alloziert und soll nun gelöcht werden. Schon hier scheitert das Ganze. Ich habe nun einige Zeit versucht das Problem selber zu lösen, aber irgendwie komme ich einfach nicht darauf... Ich bin sicher das ist kein Problem für euch Profis!

Vielen Dank im Voraus!

MIN und MAX :

#define MAX(a,b)((a) >= (b) ? (a) : (b))
#define MIN(a,b)((a) <= (b) ? (a) : (b))

for (int i=0; i < minsize; ++i)
{
 cIntBin[i] &= bi.cIntBin[i]
}

?
und die ganzen new/delete usw. sind weg...
Vorausgesetzt man hat hat in der Konstruktoren und Zuweisungen alles richtig gemacht.

P.S. Allerdings hast Du so nach wie vor einen Bug wenn Du bei der unterschiedlichen Längen... Die char-arrays müssen dann von links gefüllt werden.

Fällt die da was auf? Mit std::string wäre es nicht passiert ...

BinaryInt BinaryInt::operator&(const BinaryInt bi)
{
	int size	= MAX(strlen(cIntBin), strlen(bi.cIntBin)) + 1;		// + 1: Null Terminator
	int minsize = MIN(strlen(cIntBin), strlen(bi.cIntBin));

	//char* res = new char[size];

	for (int i=0; i < minsize; ++i)
		cIntBin[i] &= bi.cIntBin[i];
		//res[i] = (cIntBin[i] == '1' && bi.cIntBin[i] == '1') ? '1' : '0';

	//res[minsize] = '\0';

	//BinaryInt Copy(*this);
	//delete [] Copy.cIntBin;
	//Copy.cIntBin = new char[strlen(res)];
	//strcpy(Copy.cIntBin, res);
	//delete [] res;

	return *this;        // HEAP CORRUPTION #138
}

Jetzt tritt eine Heap Curruption #138 auf. Falls es an den Konstruktoren liegt, hier nochmal der Code:

BinaryInt::BinaryInt()
	: cIntBin(0), cIntDec(0)
{}

BinaryInt::BinaryInt(char* DecInt)
	: cIntBin(new char[strlen(DecInt)]), cIntDec(new char[5])
{
	strcpy(cIntBin, DecInt);
	strcpy(cIntDec, "55555");
}

BinaryInt::BinaryInt(const BinaryInt& bi)
	: cIntBin(new char[strlen(bi.cIntBin)]), cIntDec(new char[strlen(cIntDec)])
{
	strcpy(cIntBin, bi.cIntBin);
	strcpy(cIntDec, bi.cIntDec);
}

// + 1: Null Terminator

mindestens fünfmal vergessen.

siehe oben

Man hat Dir schon mehrmals beantwortet .
Und wie gesagt. So eine UND-operation funktioniert nur bei BigEndians richtig..
Da muss Du dir ganz bewusst vor Augen führen, was das für die Konsequenzen hat.

BinaryInt BinaryInt::operator&(const BinaryInt bi)
{
	int size	= MAX(strlen(cIntBin), strlen(bi.cIntBin)) + 1;		// + 1: Null Terminator
	int minsize = MIN(strlen(cIntBin), strlen(bi.cIntBin));

	char* res = new char[size];

	for (int i=0; i < minsize; ++i)
		res[i] = cIntBin[i] & bi.cIntBin[i];

	res[minsize] = '\0';

	delete [] cIntBin;
	cIntBin = new char[size];
	strcpy(cIntBin, res);
	delete [] res;

	return *this;
}

Wieso duplizierst Du zum Schluß eigentlich res nochmal und löscht dann das Original statt res einfach cIntBin zuzuweisen?

Warum nutzt Du nicht std::string oder std::vector?

Eventuell ist mein = Operator das Problem (dort erhalte ich auch beim ersten delete[] den o.g. Error), den ich auch in meinem Kopierkonstruktor verwende:

BinaryInt& BinaryInt::operator=(const BinaryInt& bi)
{
	if (*this != bi)
	{
		delete [] cIntDec;
		delete [] cIntBin;

		cIntDec = new char[strlen(bi.cIntDec) + 1];
		cIntBin = new char[strlen(bi.cIntBin) + 1];

		strcpy(cIntDec, bi.cIntDec);
		strcpy(cIntBin, bi.cIntBin);
	}

	return *this;
}

template< typename T >
bool __inline SafeNewArray( T*& instance, size_t anzahl )
{
	try
	{
		instance = new T[ anzahl ];
	}
	catch( std::bad_alloc& /*not_needed*/)
	{
		instance = 0;
		return false;
	}
	return true;
}

template< typename T >
void SafeDeleteArray( T*& p )
{
	delete[] p;
	p = 0;
}

BinaryInt& BinaryInt::operator=( const BinaryInt& bi )
{
    //if (*this != bi)
	if ( this != &bi )	// Kein versteckter Operator==(... )
    {
        //delete [] cIntDec;
        //delete [] cIntBin;

		size_t newSizeDec = strlen( bi.cIntDec ) + 1;
		size_t newSizeBin = strlen( bi.cIntBin ) + 1;
		if ( newSizeDec != 0  &&  newSizeBin != 0 )
		{
			char* decTmp = 0;
			char* binTmp = 0;
			if ( !SafeNewArray( decTmp, newSizeDec )  ||  !SafeNewArray( binTmp, newSizeBin ) )
			{
				// Zu wenig Speicher...
				// Was ist zu tun ?

				// z.B. alles lassen wie es ist.
				SafeDeleteArray( decTmp );
				SafeDeleteArray( binTmp );
				return ( *this );
			}

			//strcpy(cIntDec, bi.cIntDec);
			//strcpy(cIntBin, bi.cIntBin);

			// Die strings sicher kopieren...
			// Hie stehen Dir je nach OS/Compiler unterschiedliche Möglichkeiten zu Verfügung.
			errno_t result = strcpy_s( decTmp, newSizeDec, bi.cIntDec );
			if ( result != 0 )
			{
				// Fehler- blabla...
				// Was ist zu tun ?
			}

			result = strcpy_s( binTmp, newSizeBin, bi.cIntBin );
			if ( result != 0 )
			{
				// Fehler- blabla...
				// Was ist zu tun ?
			}

			// Alles richtig.
			SafeDeleteArray( cIntDec );
			SafeDeleteArray( cIntBin );

			cIntDec = decTmp;
			cIntBin = binTmp;
		}
		else
		{
			// Overflow -> was ist zu tun ?
			// Ist aber unrealistisch, da die Konstruktoren vorher schon aussteigen würden.
		}

    }

    return *this;
}

Was soll das überhaupt? Deine SafeXXXArrays sind vielleicht gegen Exceptions sicher die sowieso nie fliegen, aber nicht gegen ganz normale Exceptions im Code oder nachlässige Programmierer. Ein RAII-Design wäre sicher gegen alles

Mal ganz ehrlich... wenn man soweit ist, solchen Code zu verwenden, dann kann man sich gratulieren und zugestehen, dass man die Problematik verstanden hat. Anschließend wirft man das raus und benutzt std::string/std::vector .

richtig
aber es wurde ja ausdrücklich so gewünscht:)

class BinInt
{
	typedef unsigned bi_type;
public:
	BinInt() : val_(0) {}
	BinInt(const BinInt& b) : val_(b.val_) {}
	BinInt(bi_type v) : val_(v) {}
	BinInt operator &(const BinInt& b)
	{
		return BinInt(val_ & b.val_);
	}
	BinInt& operator &=(const BinInt& b)
	{
		val_ &= b.val_;
		return *this;
	}
	BinInt& operator =(const BinInt& b)
	{
		val_ = b.val_;
		return *this;
	}
	BinInt operator &(bi_type b)
	{
		return BinInt(val_ & b);
	}
	BinInt& operator &=(bi_type b)
	{
		val_ &= b;
		return *this;
	}

	friend ostream& operator<<(ostream& o, const BinInt& b);

private:
	bi_type val_;
};

ostream& operator <<(ostream& o, const BinInt& b)
{
	for(int i=sizeof(BinInt::bi_type)*CHAR_BIT-1;i>=0;--i)
	{
		o<<((b.val_>>i) & 1?'1':'0');
	}
	return o;
}

@DocShoe:
Ich weiß, dass man sowas in der Praxis nicht machen wird - zumal std::string und std::vector perfekt funktionieren. Mir geht es, aber (wie schon erwähnt) um den Lerneffekt.

Diese Klasse wird dann von deinem BinaryInt benutzt, der BinaryInt kümmert sich dann nur noch um seine eigenen Sachen und nutzt deren zur Verügung gestellte Funktionalität, um sein Ding zu machen.

Das nennt man dann Kapselung.

@Travor:
Ich habe mal deinen Code umgesetzt. Jetzt crasht es, aber schon beim strcyp_s ("Zugriffsverletzung").

Ich befürchte Du muss dein Code hier komplett stellen damit wir den Fehler entdecken können.