template <class T>
class array
{
    private:
	T *array_eindim;

	unsigned int zeilen_array;
	unsigned int index_z;

    public:
	array();
	array(unsigned int z);
	array(array<T> const& ref);
	~array();

	T *get_array();
	T get_element(unsigned int zeile);
	//unsigned int get_zeilen(); //sinnlos

	void ausgabe_array();
	void set_dim(unsigned int z);

	void push_back(T data);//zu machen
	void push_back(T *feld, unsigned int zeilen_feld);
	void push_pos(T data, int pos_z);
	void push_pos(T *feld, unsigned int zeilen_feld, int pos_z);

	T mult(T *feld, unsigned int zeilen_feld);

	int _struct_search_(T data);

	void clear_all();
};

...

/////////////////////////////////PROJEKT_T_PARSER////////////////////////////////////////////////////////
template <class T>
int array<T>::_struct_search_(T data)
{
	int pos;
	struct *s;

	for(unsigned int i = 0; i < index_z; i++) //muss eh nie weiter als bis zur letzten benutzten zeile
	{
		s = &array_eindim[i];

		if(*s.pos == data)
		{
			pos = i;
			return pos;
		}
		else return false;
	}
}
/////////////////////////////////PROJEKT_T_PARSER////////////////////////////////////////////////////////

mir kams nur so in den kopf das es so ausehen könnte, also bitte nicht böse sein auf jeden fall muss ich in dieser suchfunktion an einer stelle des arrays, in dem ein struktur liegt, in dieser struktur nach daten suchen.

angenommen so sieht die struktur aus:

struct mat_data
{
	char sign;
	int pos;
}md;

wie kann ich in einem solchen array voller strukturen nach der variable pos suchen?

bei bedarf kann ich noch die klassenimplementation posten...

Hmmm, komisches konstrukt. Ich muss dich Leider entäuschen aber sowas geht nicht

struct ist kein Datentyp wie int oder andere.
Du willst ja ein Zeiger auf eine struktur und zwar auf die Struktur die du in deinem Array hast. Und woher kriegst du raus welchen strukturtyp du hast...

Genau mit deinem template parameter T.

Also sollte die Stelle so aussehen:

T *s;

template <class T>
int array<T>::_struct_search_(T data)
{
	int pos;
	T *s;

	for(unsigned int i = 0; i < index_z; i++) //muss eh nie weiter als bis zur letzten benutzten zeile
	{
		s = &array_eindim[i];

		if(s->pos == data)
		{
			pos = i;
			return pos;
		}
		else return false;
	}
}

und du meinst, dass das oben funzt

ich hätte nicht gedacht dass ich in eine variable eine struktur packen kann?!

T ist keine Variable sondern ein generischer Datentyp

char* convert::own_str()
{
	for(int i = 0; i <= str_length; i++)
	{
		new_str[i] = verify_search(numbers, letters, extra, i);
	}
	return new_str;
}

instantiated from here

dann bekomm ich diverse fehler an verschiedenen stellen (s.u.).
wenn ichallerdings

new_str[i] = verify_search(numbers, letters, extra, i);

auskommentiere compilliert er aber ohne meckern (nat. auch unteren code) :

SONST:

template<class A>
char verify_search(array<A> mat1, array<A> mat2, array<A> mat3, int pos)
{
	A s;
	char c;
	if(mat1._struct_search_(pos))
	{
		int z = mat1._struct_search_(pos);
		s = mat1.get_element(z);
		c = s.sign;
		return c;
	}
	if(mat2._struct_search_(pos))
	{
		int z = mat2._struct_search_(pos);
		s = mat2.get_element(z);
		c = s.sign;
		return c;
	}
	if(mat3._struct_search_(pos))
	{
		int z = mat3._struct_search_(pos);
		s = mat3.get_element(z);
		c = s.sign;
		return c;
	}
}

no matching function for call to `array<mat_data>::_struct_search_(int&)'

template <class T>
int array<T>::_struct_search_(T data)
{
	T *s;

	for(unsigned int i = 0; i < index_z; i++) //muss eh nie weiter als bis zur letzten benutzten zeile
	{
		s = &array_eindim[i];

		if(s->pos == data)
			return i;

		else return false;
	}
}

candidates are: int array<T>::_struct_search_(T) [with T = mat_data]

dafür funktioniert meine neue ausgabefkt. aber einwand-frei :

template <class T>
void array<T>::_ausgabe_struct_array_()
{
	T *var;

	for(unsigned int i = 0; i < index_z; i++)
	{
		std::cout<<"\n";
		var = &array_eindim[i];
		std::cout<<"sign: "<<var->sign<<" pos: "<<var->pos;
	}
    if(zeilen_array == 0)
        std::cout << "Array leer!" << std::endl;
}

int array<mat_data>::_struct_search_(mat_data)

Aber für deinen Such-Code benötigst du etwas ganz anderes:

int array<mat_data>::_struct_search_(int&)

(zehn Strafpunkte für jeden, der den Unterschied nicht erkennt ;))

Btw, wenn du sowieso nur mit "struct mat_data" als Datentyp arbeitest, wozu brauchst du dann Templates?