leider finde ich im Netz nichts, auch hier über die Suche nicht - oder ich hab die falschen Suchbegriffe...

Gerade bin ich beim Thema templates und ich habe einen Code geschrieben in dem ich das ausprobieren wollte.
Wie ihr nachfolgend seht, möchte ich ein Array per Eingaben füllen und sortieren lassen.

Bitte helft mir bei folgenden Problemen:

1. In der template-Funktion kommen die Arrays nicht an, bzw. nach der Übergabe der Arrays hat das int Array nur 1 Element, anstatt 5. Das string Array hat 0 Elemente.
-> Warum..?

2. Wie kann ich die Eingabe der Werte realisieren..?
getline( cin, Array[i] ) funktioniert ja nicht, weil sie ja nur strings akzeptiert und beim Aufruf mit dem int Array ist das natürlich Mist.
Und bei cin >> Array[i] hätte ich ja das Problem dass ich, bei Texteingabe, die Eingabe nur bis zum ersten Leerzeichen erhalte.
cin.ignore( 1, '\n' ) hilft auch nicht, weil ich beim int Array ja dann zwei Eingaben machen MUSS und der string ist ja so trotzdem begrenzt.
-> oder ist das gar nicht möglich beide Varianten auf einmal abzudecken..?

3. Gibt es eine elegantere Methode die Anzahl der Elemente eines Arrays zu ermitteln wie meine..?

Hier mal der Code:

#include <iostream>
#include <string>

using namespace std;

/*	Prototypen
	-------------------------------------------------------------------------- */
/* --> Template Anzahl der Array Elemente ermitteln */
template <typename type>
inline int intAnzahlArrayElemente( type Array[] )
{
	/* Rückgabe der Anzahl */
	return( sizeof( Array ) / sizeof( type ) );
}

/* --> Template Elemnte des Arrays eingeben */
template <typename type>
inline void voidElementeEingeben( type Array[] )
{
	int intElemente;
	type typeEingabe;
	intElemente = intAnzahlArrayElemente( Array );

	for ( int i = 0; i < intElemente; i++ )
	{
		cout << "  " << i+1 << ". Wert: ";

		/* ----------------------------------------------------------
			Hier möchte ich vom User Eingaben abfragen, damit
			das aktuelle Array damit gefüllt wird

			--> wie kann ich das lösen..??

		   ---------------------------------------------------------- */
	}
}

/* --> Template Array sortieren */
template <typename type>
inline void voidSortiere( type Array[] )
{
	int intElemente;
	type type_tmp;

	intElemente = intAnzahlArrayElemente( Array );

	for ( int i = 0; i < ( intElemente-1 ); i++ )
	{
		for ( int j = i; j < ( intElemente ); j++ )
		{
			if ( Array[ i ] > Array[ j ] )
			{
				type_tmp   = Array[ i ];
				Array[ i ] = Array[ j ];
				Array[ j ] = type_tmp;
			}
		}
	}

	for ( int i = 0; i < intElemente; i++ )
	{
		cout << "     " << Array[ i ] << '\n';
	}
}

/* --> Template Klasse */
template < typename type1, typename type2, typename type3 >
class tmpKlasse
{
	private:
		string strObjektName;
		type1 Var1;
		type2 Var2;
		type3 Var3;

	public:
		tmpKlasse(string strOName, type1 Var1_, type2 Var2_, type3 Var3_):
			strObjektName(strOName), Var1(Var1_), Var2(Var2_), Var3(Var3_)
			{ cout << "Objekt " << strObjektName << " -> erzeugt..!\n"; };

		type1 type1GetVar1(){ return Var1; }
		type2 type2GetVar2(){ return Var2; }
		type2 type3GetVar3(){ return Var3; }

		void voidDatenausgabe()
		{
			cout << "  Var1: " << Var1 << '\n'
				 << "  Var2: " << Var2 << '\n'
				 << "  Var3: " << Var3 << "\n\n";
		}
};

/*	Hauptprogramm
	-------------------------------------------------------------------------- */
void main()
{
	int intArray[5];
	string strArray[7];

	cout << "Template Funktionen\n"
		 << "-----------------------------------------\n\n"
		 << "  intArray befuellen\n"
		 << "  ------------------\n";
	voidElementeEingeben<int>( intArray );

	cout << "  strArray befuellen\n"
		 << "  ------------------\n";
	voidElementeEingeben<string>( strArray );

	cout << "\n  Sortierte Ausgabe der Arrays verschiedener Typen\n"
		 << "  ------------------------------------------------\n"
		 << "  -> int-Array:\n";
	voidSortiere<int>( intArray );

	cout << "\n  -> string-Array:\n";
	voidSortiere<string>( strArray );

	cout << "\n-----------------------------------------------\n"
		 << "-----------------------------------------------\n\n"
		 << "Template Klasse\n\n"
		 << "-----------------------------------------\n\n";
	/* Objekte aus der tmpKlasse erzeugen */
	tmpKlasse< string, string, string> tmpK_Objekt1( "1 - nur string-Attribute", "Klasse", "mit", "String Attributen" );
	      /* < Argumentliste..!!     > */
	tmpKlasse< string, int, float> tmpK_Objekt2( "2 - gemischte Attribut-Typen", "Klasse mit int & float", 50, 326.14 );

	cout << "\n  Ausgabe uber Klassen-Mehtode:\n"
		 << "-------------------------------\n";
	tmpK_Objekt1.voidDatenausgabe();
	tmpK_Objekt2.voidDatenausgabe();

	cout << "\n  Ueber getter-Methode:\n"
		 << "-------------------------------\n"
		 << "  Var1: " << tmpK_Objekt1.type1GetVar1() << '\n'
		 << "  Var2: " << tmpK_Objekt1.type2GetVar2() << '\n'
		 << "  Var3: " << tmpK_Objekt1.type3GetVar3() << "\n\n"
		 << "  Var1: " << tmpK_Objekt2.type1GetVar1() << '\n'
		 << "  Var2: " << tmpK_Objekt2.type2GetVar2() << '\n'
		 << "  Var3: " << tmpK_Objekt2.type3GetVar3() << "\n\n";

	system("Pause");
}

PS: die Klasse funktioniert einwandfrei - trotzdem bin ich natürlich für Verbesserungsvorschläge offen..!

Danke schon mal im Voraus..!!

Gruß

Eisenspitze

void foo(T a[])

ist äquivalent zu

void foo(T* a)

Nimm entweder eine Referenz auf ein Array, oder noch viel besser: std::array.

zumal das hier auch nicht geht:

template <typename type>
inline int intAnzahlArrayElemente( type Array[] )
{
    /* Rückgabe der Anzahl */
    return( sizeof( Array ) / sizeof( type ) );
}

da der parameter ja "type * array" ist wird hier nur die grösse eines typ eines zeigers(der auf einem system normalerweise immer konstant ist) durch die grösse des typs selbst geteilt

bsp:
int auf 32Bit Betriebssystem -> 4 / 4 = 1
double auf 32Bit Betriebssystem -> 8 / 4 = 2

aber das ist unabhängig von deinem array...

um trotzdem die grösse zu behalten musst du sie entweder mitspeichern oder durch z.b. Nullterminierungen berechenbar machen
es gibt auch einen hack mit templates, aber da müssten die profis was zu sagen

Leider hab ich Schwierigkeiten das zu verstehen.
Mir ist klar dass

void foo( T a[] )

gleich

void foo( T *a )

ist - aber warum std::array..?
Ist das durch

using namespace std;

nicht sowieso schon erledigt..?
Zudem - bei std::array oder std::vektor meckert Visual...

Den Zugriff per Referenz werde ich jetzt mal ausprobieren.

Das mit der Ermittlung der Anzahl leuchtet mir ein, d.h. das letzte Element im Array müsste \0 sein..?

das einzige was in dem fall wirklich hilft, ist sich die grösse zu merken. und daher, wieso das rad neu erfinden wenn es schon zig mal neu erfunden wurde?!
==>
zu vector
zu array(ein eingekapseltes statisches array, was mehr sicherheit und funktionalität bietet als das rohe array)

...in einem int array kommt es schon öfters mal vor dass es nullen gibt, und das nicht am ende

stimmt, da war ja noch was... :p

Danke für die Links..! Das werd ich mir mal anschauen.

Hast du vielleicht auch noch einen Tipp für die Abfrage der Daten..? (Problem Nr. 2)

halbwegs gut klappts vielleicht wenn du eine string zeile einliest, diese dann in einen stringstream stopfst und daraus dann dein datum rausholst

guckst du hier:

std::string s;
std::getline(std::cin, s);

std::stringstream ss;
ss << s;

type x;
ss >> x;

aber da musst du dir über die fehlerbehandlung im klaren sein.

Mit Fehlerbehandlung meinst du

cin.fail()

oder..?

Wie kommst du auf Datum..?

Mal so nebenbei, das Bsp. habe ich mir frei einfach so ausgedacht - war das einfach Mist..? Also ich meine wie oft würde man sowas als template anlegen, eine Funktion die Text & Zahlen verarbeiten soll..? ..deiner Erfahrung nach..?

tja, mit erfahrung mangelts bei mir. dazu kann ich nur sagen, ich hab keien erfahrung...

aber ich wäre da halt ziemlich vorsichtig was die eingabe betrifft, da kann man den user mit richtig nerven, man kann die sicherheit des programms und damit des computers anfechten (guck mal den tanenbaum zum thema betriebssystem sicherheit, buffer overflow usw.)

edit: eingaben sollte man weniger generisch machen, da kann man ruhig konkreter werden

fail bits

Es gibt keine fail bits. Nur error-bits und das failbit.

Wieso machst du überhaupt die Pufferung durch den Stringstream? Gerade std::getline mit einem LF als Delimitter ist nicht gut, da ein überladener left-shift Operator auch

std::ostream& operator<<(std::ostream& os, T const& t)
{
    return os << t.getThis() << '\n' << t.getThat();
}

so aussehen kann (unsinnig aber möglich).

aber ich wäre da halt ziemlich vorsichtig was die eingabe betrifft, da kann man den user mit richtig nerven, man kann die sicherheit des programms und damit des computers anfechten (guck mal den tanenbaum zum thema betriebssystem sicherheit, buffer overflow usw.)

Wenn mann es richtig macht dann ist daran garnix nervig oder gefährlich...

Nur mit

std::string s;
std::getline(std::cin, s);

std::stringstream ss;
ss << s;

type x;
ss >> x;

klappt´s dann leider nicht, der Compiler gibt mir da

error C2678: Binärer Operator '>>': Es konnte kein Operator gefunden werden, der einen linksseitigen Operanden vom Typ 'std::stringstream' akzeptiert (oder keine geeignete Konvertierung möglich)

aus.

So wie ich die Arrays am Anfang erstellt und übergeben habe, funktioniert es so (beim testen hab ich die Array-Größe mit übergeben )

Also danke noch mal für eure (schnelle..!!) Hilfe..!

@Sone
Wie würdest du das lösen..?

std::vector<int> vec(5);
        for(size_t n(0);n < 5;++n)

                while(!(std::cin >> vec[n]))
                {
                        std::cout << "Error! Type in a number, please!\n";
                        std::cin.clear();
                        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                }

Wie würde ich eine Menge von Zahlen von der Konsole einlesen?

Hm, aber es ging ja darum eine Lösung zu finden, dass ich es in der tamplate Funktion hinbekomme int UND strings einzulesen.
Mit dem selben Code.
Und zwar so, dass das einlesen der Eingabe bei einer Zahl nach der Zahl endet, wie es cin << Var eben tut; und das Einlesen nach der Zeilenschaltung, wie es getline() eben tut.

Für Zahlen funktioniert deine Methode natürlich, aber beim string hilft das wenig..oder verstehe ich daran irgendetwas nicht..?

Für Zahlen funktioniert deine Methode natürlich, aber beim string hilft das wenig..oder verstehe ich daran irgendetwas nicht..?

Wunderbar funktioniert das für Strings. Probier es doch aus.

Leider klappt es eben nicht..!

Das ist der Code:

#include <string>
#include <iostream>
#include <vector>

using namespace std;

void main()
{
	std::vector<string> strvec(5);
        for(size_t n(0);n < 5;++n)
        {
                while(!(std::cin >> strvec[n]))
                {
                        std::cout << "Error! Type in a number, please!\n";
                        std::cin.clear();
                        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                }
        }

		for(size_t n(0);n < 5;++n)
		{cout << strvec[n] << "\n";}

	system("Pause");
}

Also genau deiner nur eben für strings.

Wenn ich:

"Hallo Du"
"ein Test"
"und geht nicht"

eingebe, kommt

Hallo
Du
ein
Test
und

heraus..!

Ach, btw: void main() ? Ist das dein ernst?

Kannst du mir da auf die Sprünge helfen..? Hab grad im Netz gesucht und rumgespielt, aber ich bekomm´s nicht hin...

Meinst du ios::skipws..?

Spezialisierung ist mir bekannt, nur wie muss ich´s mit ios::skipw schreiben..?

Achso, das void main hab ich nur drin weil das im Skript so stand, wobei ich irgendwo im Hinterkopf hab dass es immer int main sein MUSS.
-> stimmt das..?
-> welche Hintergründe gibt´s da..?

Was du machen könntest ist eine Überladung mit einer Templatefunktion:

template<typename t>
std::istream& readFrom(std::istream& is, t& toread)
{
    return is >> toread;
}

std::istream& readFrom(std::istream& is, std::string &toread)
{
    return std::getline(is, toread);
}

du musst dir das so vorstellen, dein compiler bettet dein programm in eine laufzeitumgebung ein, die in etwa so aussieht:

someFunction();
// ...
int returnValue = main();
if ( returnValue == ... )
    ...
somefunction();

void main ist halt kein standardkonformes C++

bei deinem letzten programm lässt du auch nur 5 worte eingeben durch die schleifen, daher nicht wundern wenn nur 5 wieder rauskommen

Damit ich´s richtig verstehe:
Damit haben wir jetzt eine überladene Template-Funktion und der Compiler sucht sich die richtige raus, je nach dem ob´s ein string Vektor ist, oder ein anderer..?

@Skym0sh0
Danke für die Erkärung..!

mit änderung:

template<typename T>
std::istream& readFrom(std::istream& is, T & toread)
{
    return is >> toread;
}

template<>
std::istream& readFrom(std::istream& is, std::string & toread)
{
    return std::getline(is, toread);
}

nicht dass dann probleme bei überladung oder überdeckung gibt...

template<>
std::istream& readFrom(std::istream& is, std::string & toread)
{
return std::getline(is, toread);
}
[/cpp]

nicht dass dann probleme bei überladung oder überdeckung gibt...

Deine Version ist so eigentlich falsch.

template<>
std::istream& readFrom<std::string>(std::istream& is, std::string & toread)
{
    return std::getline(is, toread);
}

Und meine ist vollkommen korrekt und leichter zu lesen, denn es ist eine Überladung; für den Compiler stehen non-template functions an erster Stelle, danach kommen erst Template-Funktionen.

Außerdem kennt jeder die Regel: Templatefunktions-Spezialisierungen sind schlecht, sie überladen nicht.

Könnt ihr das vielleicht näher erklären..? ..oder mir was zu lesen geben..?

Es geht um den Unterschied zwischen

std::istream& readFrom<std::string>(std::istream& is, std::string & toread)

und

std::istream& readFrom(std::istream& is, std::string & toread)

oder..?

Mal so nebenbei, warum ist mein eingebetteter Code eigentlich nur schwarz/weiß..?

ok, mit den templates komme ich langsam auch nicht mehr so mit.

ich, mit meiner intuition, würde das template so schreiben wie vorgeschlagen. und es dann für std::string weiter spezialisieren

ich habs auch grad mal getestet (VC2010 unter Win7 64), da klappt sowohl die überladung neben dem template und der spezialisierung

#include <iostream>

template<typename T>
T maximum(T const& a, T const& b) //template
{
	return a<=b ? b : a;
}

template<>
float maximum<float>(float const& a, float const& b) //spezialisiertes template
// oder 
// float maximum(float const& a, float const& b)  geht auch!
{
	std::cout << "Template Spez" << std::endl;
	if ( a < b )
		return b;
	else
		return a;
}

float maximum(float const& a, float const& b) // normale funktion
{
	std::cout << "Non-Template" << std::endl;
	if ( a < b )
		return b;
	else
		return a;
}

int main(int argc, char * argv[])
{
	std::cout << maximum(4355.0f, 7.0f) << std::endl; // ruft die normale funktion auf
        std::cout << maximum<float>(4355.0f, 7.0f) << std::endl; // ruft die template spez auf
        std::cout << maximum(4355.0, 7.0) << std::endl; // ruft maximum<double> auf, also das template

	return 0x0;
}