Fehler bei Sortieralgorithmus

isn kopierfehler, das ist ne templatefunktion, T is der Templatetyp. Wenn du den op= der Arrayklasse meintest (wieso auch immer):

template <class T> Array<T>& Array<T>::operator=(const Array<T>& rhs)
{
	if (*this == rhs)
	{
		return *this;
	}
	else
	{
		delete[] Ar;
		Range = rhs.size();
		try
		{
			Ar = new T[Range];
		}
		catch(...){Ar = 0; return *this;}	
		for(int i=0; i<Range; ++i)
		{
			Ar[i] = rhs[i]; 
		}		
		return *this;
	}
}

*push*

Geo

delete[] Ar; // ?????

Was ist Ar, bzw. wo ist das definiert?

Jester

Ich glaube es wahr eher der op= von T gemeint, nicht der vom Array.

MfG Jester

SideWinder

BTW: Man prüft auf this==&rhs und nicht auf *this==rhs, sonst brauch die Sache plötzlich auch noch einen op==.

MfG SideWinder

@Geo: ar ist Ar, hab mich vertippt.

@Jester: T ist ein Templateargument -> kenn op= von T net. Ich hab zum testen int verwendet

@SideWinder: danke

Glamdring

Ich zeig euch mal den ganzen Quellcode, is net besonders dolla aber:
Myarray.h

#ifndef My_ARRAY_H
#define My_ARRAY_H

#include <cassert>

namespace normal
{
	int value = 10;
}

template <class value = int> class Array //Vielleicht später mehrdimensionale Arras erlauben
{
private:
	int Range;
	value* Ar; 
	value* second;
	value t;
public:
	Array();
	explicit Array(int n);
	Array(int nRange, value value);
	Array(Array& rhs);

	~Array();

	int size() const;
	void resize(int n);  //changes the Range of the Array, makes a 
						 //new one and take the values of the first Array
	void sort();         //small Elemnts are in the front, big are in the back of the Array
	void reverse_sort(); //just the other way round =)

	bool operator==(const Array<value>& rhs) const;
	bool operator!=(const Array<value>& rhs) const;
	Array<value>& operator=(const Array<value>& rhs);
	value& operator[](int n) const;

	void assign(value value); //All Datas in the Array get the value of value
};

template <class T> Array<T>::Array():second(0)
{
	Range = normal::value;
	try
	{
		Ar = new T[Range];
	}
	catch(...){Ar = 0;}
}

template <class T> Array<T>::Array(int n): second(0)
{
	Range = n;
	try
	{
		Ar = new T[Range];
	}
	catch(...){Ar = 0;}
}

template <class T> Array<T>::Array(int nRange, T value): second(0)
{
	Range = nRange;
	try
	{
		Ar = new T[Range];
	}
	catch(...)
	{
		Ar = 0;
		return;
	}
	asssign(value);	
}

template <class T> Array<T>::Array(Array<T>& rhs) : second(0)
{
	Range = rhs.size();
	for(int i=0; i<Range; ++i)
	{
		try
		{
			Ar[i] = rhs[i];
		}
		catch(...){/*Fehler im Operator-= von T, da kann man nichts machen*/}
	}

}

template <class T> Array<T>::~Array(){if(Ar) delete Ar;}

template <class T> int Array<T>::size() const
{
	return Range;
}

template <class T> void Array<T>::sort()
{
	for (int i=1; i < Range+1; ++i)
	{
		for (int k=0; k < Range-1-i; ++k)
		{
			if(Ar[k] > Ar[k+1])
			{
				try
				{
					t = Ar[k];
					Ar[k] = Ar[k+1];
					Ar[k+1] = t;
				}
				catch(...){/*Fehler im Operator-= von T, da kann man nichts machen*/}
			}
		}
	}
}

template <class T> void Array<T>::reverse_sort()
{
	for (int i=1; i < Range+1; ++i)
	{
		for (int k=0; k < Range-1-i; ++k)
		{
			if(Ar[k] < Ar[k+1])
			{
				try
				{
					t = Ar[k];
					Ar[k] = Ar[k+1];
					Ar[k+1] = t;
				}
				catch(...){/*Fehler im Operator-= von T, da kann man nichts machen*/}
			}
		}
	}
}

template <class T> bool Array<T>::operator==(const Array<T>& rhs) const
{
	if(rhs.size() != Range)
	{
		return false;
	}
	for (int i=0; i<Range; ++i)
	{
		try
		{
			if(rhs[i] == Ar[i])
			{
				continue;
			}
			else
			{
				return false;
			}
		}
		catch(...){/*Fehler beim Operator-== von T*/}
	}
	return true;
}

template <class T> bool Array<T>::operator!=(const Array<T>& rhs) const
{
	try
	{
		return !*this==rhs;
	}
	catch(...){/*Fehler beim Operator-== von T*/ return false;}
}

template <class T> Array<T>& Array<T>::operator=(const Array<T>& rhs)
{
	if (this == &rhs)
	{
		return *this;
	}
	else
	{
		delete[] Ar;
		Range = rhs.size();
		try
		{
			Ar = new T[Range];
		}
		catch(...){Ar = 0; return *this;}	
		for(int i=0; i<Range; ++i)
		{
			Ar[i] = rhs[i]; 
		}		
		return *this;
	}
}

template <class value> value& Array<value>::operator[](int n) const
{
	assert(n <= Range-1);
	return *const_cast<value*>(&Ar[n]);
}

template <class T> void Array<T>::resize(int n)
{
	try
	{
		second = new T[n];
	}
	catch(...){second = 0; return;}
	for (int i=0; i < Range && i < n; ++i)
	{
		second[i] = Ar[i];		
	}
	delete[] Ar;
	Ar = second;
	Range = n;
	second = 0;
}

template <class T> void Array<T>::assign(T value)
{
	for (int i=0; i<Range; ++i)
	{
		try
		{
			Ar[i] = value;
		}
		catch(...){}
	}
}

#endif

Main.cpp

#include "MyArray.h"
#include <iostream>
using namespace std;

int main()
{
	Array<int> intArray(10);
	Array<int> otherArray(10);
	intArray[0] = 0;
	intArray[1] = 1;
	intArray[2] = 2;
	intArray.sort();
	for(int i = 3; i < 10; ++i)
	{
		intArray[i] = i;
	}
	otherArray = intArray; 
	otherArray.resize(12);
	otherArray[10] = 10;
	otherArray[11] = 11;
	for(int a=0; a<12; ++a)
	{
		cout << otherArray[a] << endl;
	}
	return 0;
}

Ausgabe:
-842150451
-842150451
-842150451
4
5
6
7
8
9
10
11

Wenn ich aber sort zu reverse_sort mache, dann gehts, ???

mfg

Die (englischen) Kommentare ignorieren, plz

Geo

In ~Array: delete statt delete[]

Deine Ausgabe müsste doch zwölf Zeilen haben??

"value" verwendest du als Namen für eine Variable und als Typnamen. Wenn ich sowas sehe verliere ich jegliche Lust mir das weiter anzusehen.

zu 1: stimmt

zu 2: Jupp, hab ne 3 vergessen.

zu 3: stimmt auch

Der Fehler bleibt aber trotzdem