[C] Arrays aus Klassen Template an Memberfunktion übergeben

K

kanonenfutter90

Grünschnabel

Abend.

Ich habe hier leider einige Schwierigkeiten beim übergeben von Arrays.

Folgendes:

Ich habe eine Klasse angelegt
Code: 
template <class T, int t_iAnz> class CBA_LongDual
und aus dieser in der Main Funktion einige Arrays erzeugt:
Code: 
CBA_LongDual<int, 100> DualFeld1;
CBA_LongDual<int, 100> DualFeld2;
CBA_LongDual<int, 100> DualSumme;
Die beiden ersten Felder DualFeld 1 und 2 lasse ich über eine Eingabeaufforderung vom Nutzer füllen. In das dritte Feld soll die Summe der beiden ersten Felder geschrieben werden. Diese Addier-Funktion möchte ich gerne in der Klasse unterbringen.

Bisher sind leider all meine Versuche gescheitert, die Felder an die entsprechende Memberfunktion zu übergeben, egal ob ich irgendwelche Pointer übergebe oder nur einzelne Elemente. :(

Das gleiche Problem habe ich, wenn ich ein solches Feld in eine Dezimalzahl wandeln möchte. Hier hatte ich es mir zB so gedacht, dass ich in der MainFkt. einfach die Funktion
Code: 
iDez = DualFeld1.Dual2Dez(...);
aufrufe. Die Fkt. Dual2Dez soll dann in der Klasse behandelt werden. Hierzu müsste ich also das Feld DualFeld1 übergeben können. Leider weiß ich nicht ob und was an Stelle der ... in meinen Klammern stehen müsste.

Ich stehe diesbzgl. noch nicht tief in der Materie und hoffe ihr könnt mir mit ein paar guten Ansätzen weiter helfen :)

Danke im Voraus

mfg
 
Zuletzt bearbeitet:
Hi.

Es ist gut, wenn du uns im Titel die Sprache nennst um die es geht, aber wenn es sich um C++ handelt, dann solltest du auch c++ schreiben.

kanonenfutter90 hat gesagt.:
Ich habe eine Klasse angelegt
Code: 
template <class T, int t_iAnz> class CBA_LongDual
und aus dieser in der Main Funktion einige Arrays erzeugt:
Code: 
CBA_LongDual<int, 100> DualFeld1;
CBA_LongDual<int, 100> DualFeld2;
CBA_LongDual<int, 100> DualSumme;
Zum Vergrößern anklicken....
Das sind keine Arrays.
kanonenfutter90 hat gesagt.:
Die beiden ersten Felder DualFeld 1 und 2 lasse ich über eine Eingabeaufforderung vom Nutzer füllen. In das dritte Feld soll die Summe der beiden ersten Felder geschrieben werden. Diese Addier-Funktion möchte ich gerne in der Klasse unterbringen.

Bisher sind leider all meine Versuche gescheitert, die Felder an die entsprechende Memberfunktion zu übergeben, egal ob ich irgendwelche Pointer übergebe oder nur einzelne Elemente. :(
Zum Vergrößern anklicken....
Und wir sollen jetzt raten was du alles versucht hast und wie deine Klasse momentan aussieht? ;-]

kanonenfutter90 hat gesagt.:
Das gleiche Problem habe ich, wenn ich ein solches Feld in eine Dezimalzahl wandeln möchte. Hier hatte ich es mir zB so gedacht, dass ich in der MainFkt. einfach die Funktion
Code: 
iDez = DualFeld1.Dual2Dez(...);
aufrufe. Die Fkt. Dual2Dez soll dann in der Klasse behandelt werden. Hierzu müsste ich also das Feld DualFeld1 übergeben können.
Zum Vergrößern anklicken....
Wenn Dual2Dez eine nicht-statische Methode der Klasse ist, dann wird die Instanz implizit als this Zeiger übergeben.
kanonenfutter90 hat gesagt.:
Leider weiß ich nicht ob und was an Stelle der ... in meinen Klammern stehen müsste.
Zum Vergrößern anklicken....
Dann müßtest du mal erläutern was das in der Gesamtheit überhaupt werden soll.

Gruß
 
deepthroat hat gesagt.:
Hi.

Es ist gut, wenn du uns im Titel die Sprache nennst um die es geht, aber wenn es sich um C++ handelt, dann solltest du auch c++ schreiben.
Zum Vergrößern anklicken....

Sry, geändert :)

deepthroat hat gesagt.:
Das sind keine Arrays.
Zum Vergrößern anklicken....

Ok aber was dann, schließlich erfüllt es doch den gleichen Zweck, oder?

deepthroat hat gesagt.:
Und wir sollen jetzt raten was du alles versucht hast und wie deine Klasse momentan aussieht? ;-]
Zum Vergrößern anklicken....

Ok, wenn es hilft stell ich mal den gesamten Text rein:
Also erstmal die MainFkt:
Code: 
#include "stdafx.h"
#include "CBA_DatenTypen.h"
#include "CBA_LongDual.h"
#include "conio.h"
#include "stdlib.h"
#include "stdio.h"

/////////////////////////////////////////////////////////////////////

int main(int argc, char* argv[])
{
	int i = 0;
	char cTaste = ' ';
	int iZeichen1[100] = {0};
	int iZeichen2[100] = {0};
	int iAnz = 0;
	int iLaenge1 = 0;
	int iLaenge2 = 0;

	CBA_LongDual<int, 100> DualFeld1;
	CBA_LongDual<int, 100> DualFeld2;
	CBA_LongDual<int, 100> DualSumme;



	printf("\nDEMONSTRATION DES DATENTYPS 'LONG DUAL' (max. 100 Stellen)\n-----------------------------------------------------------\n\n");
	
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////Eingabe/Initialisierung/Ausgabe Feld 1 und 2

	printf("Geben Sie hier die erste Dualzahl ein:		");	//										IO
	do
	{
		cTaste = getch();				//Tastaturabfrage

		if((cTaste=='1')||(cTaste=='0'))
		{
			iZeichen1[iAnz] = CBA_LongDual<int, 1>::StrToInt(cTaste);
			printf("%d", iZeichen1[iAnz]);
			iAnz++;
			iLaenge1 = iAnz;
		}
	}
	while((cTaste != 13)&&(iAnz<=99)); //Ende mit enter
	
	/////
	iAnz = 0;
	printf("\n");
	/////

	printf("Geben Sie nun die zweite Dualzahl ein:		");	
	do
	{
		cTaste = getch();

		if((cTaste=='1')||(cTaste=='0'))
		{
			iZeichen2[iAnz] = CBA_LongDual<int, 1>::StrToInt(cTaste);
			printf("%d", iZeichen2[iAnz]);
			iAnz++;
			iLaenge2 = iAnz;
		}
	}
	while((cTaste != 13)&&(iAnz<=99));

	////////////////////////

	for(i=99; i>=0; i--)					//Feld fuellen
	{
		DualFeld1.SetInhalt(iZeichen1[i-100+iLaenge1], i);
		DualFeld2.SetInhalt(iZeichen2[i-100+iLaenge2], i);
	}

	printf("\n\nEingegebene Zahl 1: ");		DualFeld1.Ausgabe(iLaenge1); printf("\n");	
	printf("Eingegebene Zahl 2: ");			DualFeld2.Ausgabe(iLaenge2); printf("\n");

/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////Addition

	printf("\n\nAddition zweier Dualzahlen\n-----------------------------------------------------------\n\n");
	
	/*Hier hängts im Moment*/	


/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////Dual2Dez
	int iDez = 0;

	
	{
		iDez = DualFeld1.Dual2Dez();  /*Und hier bin ich nicht sicher wie ich das "Feld" übergeben kann*/
	}



	printf("\n\n\n");
	return 0;
}


Und die Klasse dazu:

Code: 
#ifndef CONST_CBA_LONGDUAL_H
#define CONST_CBA_LONGDUAL_H


template <class T, int t_iAnz> class CBA_LongDual : public CBA_DatenTypen
{
protected:		// Membervariablen
	T	m_Werte[ t_iAnz ];
	int m_iWert;

public:			// Memberfunktionen
	CBA_LongDual( )
	{
		for( int i=0; i<t_iAnz; i++ )
		{
			m_Werte[i] = T();
			m_iWert = 0;
		}
	}


	~CBA_LongDual( )
	{
	}



///////////////////////////////////////////////////////////////

	void SetInhalt( T p_Element, int p_iStelle )
	{
		
		m_Werte[p_iStelle] = p_Element;
		
	}

///////////////////////////////////////////////////////////////

	int GibElement( int p_iStelle )
	{
		return m_Werte[p_iStelle];
	}

///////////////////////////////////////////////////////////////

	void Ausgabe( int Laenge )
	{
		for( int i=100-Laenge; i<=99; i++ )
		{
			printf("%d", m_Werte[i]);
		}
	}

///////////////////////////////////////////////////////////////

	int Dual2Dez( )
	{
		int iDez = 0;

		for(int i=0; i<=99; i++)
		{
			iDez = iDez*2 + CBA_LongDual. ;   ////hier weiß ich nicht weiter von wegen Werteübergabe
		}

		return iDez;
	}

///////////////////////////////////////////////////////////////

	void SpeichernLaden( FILE* p_pDatei, bool p_bSpeichern )
	{
		if( p_bSpeichern )
		{
			fprintf( p_pDatei, "%d\n", m_iWert );
		}
		else
		{
			fscanf( p_pDatei, "%d", & m_iWert );
		}
	}

///////////////////////////////////////////////////////////////

	static int StrToInt(char string)
	{
		int x = 0;
		x = atoi(&string);
		return x;
	}

};

#endif

deepthroat hat gesagt.:
Wenn Dual2Dez eine nicht-statische Methode der Klasse ist, dann wird die Instanz implizit als this Zeiger übergeben.
Zum Vergrößern anklicken....

Ok und was heißt das genau? :)

deepthroat hat gesagt.:
Dann müßtest du mal erläutern was das in der Gesamtheit überhaupt werden soll.

Gruß
Zum Vergrößern anklicken....

Im Prinzip soll ich einen Datentypen "LongDual" basteln, der max. 100Stellen behandelt. Damit sollen dann verschiedene Funktionen implementiert und in der Main demonstriert werden. Also eben zB Rechenoperationen, Vergleiche und Umwandlungen.

Hoffe das ganze ist jetzt etwas klarer? :)

mfg
 
kanonenfutter90 hat gesagt.:
Ok aber was dann, schließlich erfüllt es doch den gleichen Zweck, oder?
Zum Vergrößern anklicken....
Das kann man doch gar nicht sagen. Du hast da irgendwas mit Templates gemacht, aber ohne zu wissen wie die Template-Klasse aussieht müßte man schon Hellseher sein.

Grundsätzlich hast du dort Instanzen der Template-Klasse LongDual angelegt. Und wie Arrays verhalten sie sich augenscheinlich nicht...
kanonenfutter90 hat gesagt.:
Im Prinzip soll ich einen Datentypen "LongDual" basteln, der max. 100Stellen behandelt. Damit sollen dann verschiedene Funktionen implementiert und in der Main demonstriert werden. Also eben zB Rechenoperationen, Vergleiche und Umwandlungen.
Zum Vergrößern anklicken....
Und sollst du das mit Templates lösen? :suspekt:

kanonenfutter90 hat gesagt.:
C++: 
int Dual2Dez( )
	{
		int iDez = 0;

		for(int i=0; i<=99; i++)
		{
			iDez = iDez*2 + CBA_LongDual. ;   ////hier weiß ich nicht weiter von wegen Werteübergabe
		}

		return iDez;
	}
Zum Vergrößern anklicken....
Hier mußt du doch nur durch das interne Array m_Werte iterieren. Wobei die 99 sollte ja eigentlich die Länge des Arrays sein, also t_iAnz - 1. Wenn du schon Templates nutzt, mußt du es auch überall machen.
C++: 
iDez = iDez*2 + m_Werte[i];

Eine Additionsfunktion könntest du z.B. so schreiben:
C++: 
// als Memberfunktion
CBA_LongDual<T, t_iAnz> Plus(const CBA_LongDual<T, t_iAnz>& other) const {
   ...
}

// Aufruf:
DualSumme = DualFeld1.Plus(DualFeld2);
Dazu muß aber der Zuweisungsoperator definiert sein.

Gruß
 
Ok danke dir erstmal so weit. Mir wurde gesagt ich kann das zB über Templates machen, habe mit denen aber so gut wie keine Erfahrung, wie man wohl sieht :)

Ich arbeite parallel noch an einer zweiten Version, wo ich versuche das ganze für mich verständlich ohne Templates zu basteln. Hier funktioniert das oben genannte auch ganz gut, allerdings habe ich hier das Problem, dass ich meine ganzen Funktionen nicht wirklich in die Klasse bekomme, sondern nur in der Main deklarieren kann.

Das ganze sieht im Moment so aus (cpp der Klasse, es existiert natürlich auch eine header dazu ;)):
C++: 
#include "stdafx.h"
#include "CBA_DatenTypen.h"
#include "CBA_LongDual.h"
#include "stdlib.h"
#include "stdio.h"

///////////////////////////////////////////////////////////////

CBA_LongDual::CBA_LongDual()
{
	iEingabe = 0;	
	m_iWert = 0;
}

///////////////////////////////////////////////////////////////

CBA_LongDual::CBA_LongDual(int p_iWert)
{
	m_iWert = p_iWert;
}

///////////////////////////////////////////////////////////////

void CBA_LongDual::SetInhalt(int Eingabe)
{
	iEingabe = Eingabe;
}

///////////////////////////////////////////////////////////////

int CBA_LongDual::GetInhalt()
{
	return iEingabe;
}

///////////////////////////////////////////////////////////////

int CBA_LongDual::GibWert()
{
	return m_iWert;
}

///////////////////////////////////////////////////////////////

void CBA_LongDual::Schreibe()
{
	printf(" %d", m_iWert);
}

///////////////////////////////////////////////////////////////

void CBA_LongDual::SpeichernLaden( FILE* p_pDatei, bool p_bSpeichern)
{
	if( p_bSpeichern )
	{
		fprintf( p_pDatei, "%d\n", m_iWert );
	}
	else
	{
		fscanf( p_pDatei, "%d", & m_iWert );
	}
}

///////////////////////////////////////////////////////////////

CBA_LongDual::~CBA_LongDual()
{
}


und die dazugehörige Main Fkt.:

C++: 
#include "stdafx.h"
#include "CBA_DatenTypen.h"
#include "CBA_LongDual.h"
#include "conio.h"
#include "stdlib.h"
#include "stdio.h"

int StrToInt(char string);                                               /*zur Umwandlung der tastatureingabe*/

/////////////////////////////////////////////////////////////////////

int main(int argc, char* argv[])
{

	char cTaste			= ' ';				//Eingabe
	int iZeichen[100]	= {0};
	int iAnz			= 0;
	int iLaenge1		= 0;
	int iLaenge2		= 0;

	
	CBA_LongDual * iFeld1[100];				//Felder
	CBA_LongDual * iFeld2[100];
	CBA_LongDual * iFeldS[100];
	CBA_LongDual * iFeldDD[100];
	int i = 0;
	CBA_LongDual * LongDual;

	
	CBA_LongDual::CBA_LongDual(743);		//integer aus Konstruktor

	int iDez		= 0;					//Konvertierung
	int iRest		= 0;
	
	
	printf("\nDEMONSTRATION DES DATENTYPS 'LONG DUAL'\n-----------------------------------------------\n\n\n");
	printf("ADDITION ZWEIER DUALZAHLEN\n-----------------------------------------------\n\n");

/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////Eingabe/Initialisierung/Ausgabe Feld 1 und 2

	printf("Geben Sie hier die erste Dualzahl ein:		");	//										IO
	do
	{
		cTaste = getch();				//Tatstaturabfrage

		if((cTaste=='1')||(cTaste=='0'))
		{
			iZeichen[iAnz] = StrToInt(cTaste);
			printf("%d", iZeichen[iAnz]);
			iAnz++;
			iLaenge1 = iAnz;
		}
	}
	while((cTaste != 13)&&(iAnz<=99)); //Ende mit enter
	iAnz = 0;	//zurücksetzen
	printf("\n\n");

/////////////////////////////////////////////////////////////////////								IO

	for(i=99; i>=0; i--)					//Feld fuellen
	{
		LongDual = new CBA_LongDual; 
		LongDual->SetInhalt(iZeichen[i-(100-iLaenge1)]);
		iFeld1[i] = LongDual;
	}

	for(i=0; i<(100-iLaenge1); i++)			//restliches Feld auf 0
	{
		LongDual->SetInhalt(0);
		iFeld1[i] = LongDual;
	}

/////////////////////////////////////////////////////////////////////								IO

	printf("Geben Sie hier die zweite Dualzahl ein:		");
	do
	{
		cTaste = getch();				//Tatstaturabfrage

		if((cTaste=='1')||(cTaste=='0'))
		{
			iZeichen[iAnz] = StrToInt(cTaste);
			printf("%d", iZeichen[iAnz]);
			iAnz++;
			iLaenge2 = iAnz;
		}
	}
	while((cTaste != 13)&&(iAnz<=99)); //Ende mit enter
	iAnz = 0;	//zurücksetzen
	printf("\n\n");

/////////////////////////////////////////////////////////////////////								IO

	for(i=99; i>=0; i--)					//Feld fuellen
	{
		LongDual = new CBA_LongDual; 
		LongDual->SetInhalt(iZeichen[i-(100-iLaenge2)]);
		iFeld2[i] = LongDual;
	}

	for(i=0; i<(100-iLaenge2); i++)			//restliches Feld auf 0
	{
		LongDual->SetInhalt(0);
		iFeld2[i] = LongDual;
	}

/////////////////////////////////////////////////////////////////////								IO

	printf("Long Dual (Zahl1): ");			//Ausgabe Feld 1
	for(i=0; i<=99; i++)
	{
		printf("%d", iFeld1[i]->GetInhalt());
	}

	printf("\n\n");
	
	printf("Long Dual (Zahl2): ");			//Ausgabe Feld 2
	for(i=0; i<=99; i++)
	{
		printf("%d", iFeld2[i]->GetInhalt());
	}

	printf("\n\n");

/////////////////////////////////////////////////////////////////////Addition						IO

	int iUebertrag = 0;
	for(i=99; i>=0; i--)					//Feld fuellen
	{
	
		LongDual = new CBA_LongDual; 
		LongDual->SetInhalt(0);
		iFeldS[i] = LongDual;
		

		iFeldS[i]->SetInhalt(iFeld1[i]->GetInhalt() + iFeld2[i]->GetInhalt() + iUebertrag);
		if(iFeldS[i]->GetInhalt() >= 2)
		{
			if(iFeldS[i]->GetInhalt() % 2 == 0)
			{
				iUebertrag = iFeldS[i]->GetInhalt() / 2;
				iFeldS[i]->SetInhalt(0);
			}
			else
			{
				iUebertrag = iFeldS[i]->GetInhalt();
				iFeldS[i]->SetInhalt(1);
				iUebertrag--;
				iUebertrag = iUebertrag / 2;
			}
		}
		else
		{
			iUebertrag =0;
		}
	}
		
	printf("Dualzahl 1 + Dualzahl 2 = ");
	for(i=0; i<=99; i++)
	{
		printf("%d", iFeldS[i]->GetInhalt());
	}


/*	printf("\n");								//zur Fehleranalyse

	printf("Dualzahl 1 = ");
	for(i=0; i<=99; i++)
	{
		printf("%d", iFeld1[i]->GetInhalt());
	}
	printf("\n");

	printf("Dualzahl 2 = ");
	for(i=0; i<=99; i++)
	{
		printf("%d", iFeld2[i]->GetInhalt());
	}
*/

/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////DualToDez Umwandlung			IO

	printf("\n\n\nUMWANDLUNG DUAL => DEZIMAL\n-----------------------------------------------\n\n");

	for (i=0; i<100; i++) 
	{
		iDez = iDez*2 + iFeld1[i]->GetInhalt();
	}
	printf("Dualzahl 1 in Dezimal : %d", iDez);

		
	
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////DezToDual Umwandlung			IO

	printf("\n\n\nUMWANDLUNG DEZIMAL => DUAL\n-----------------------------------------------\n\n");

	CBA_LongDual Integer(734);
	printf("Integer mit Konstruktor erzeugt : "); Integer.Schreibe(); printf("\n\n");


	for(i=99; i>=0; i--)					//Feld fuellen
	{
		LongDual = new CBA_LongDual; 
		LongDual->SetInhalt(0);
		iFeldDD[i] = LongDual;
	}


	iDez = Integer.GibWert();
	i = 99;
	do
	{
		iRest	= iDez % 2;
		iDez	= iDez / 2;

		if( iRest != 0)
		{
			iFeldDD[i]->SetInhalt(1);
		}
		else
		{
			iFeldDD[i]->SetInhalt(0);
		}

		i--;
	}
	while(iDez > 0);

	printf("Dezimalzahl nach Dual : ");
	for(i=0; i<=99; i++)
	{
		printf("%d", iFeldDD[i]->GetInhalt());
	}




	printf("\n\n\n");
	return 0;
}


/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////

int StrToInt(char string)
{
	int x = 0;
	x = atoi(&string);
	return x;
}

Solche Funktionen wie die Addition, Umwandlung Dez <=> Dual oder auch die Stringwandlung in einen Integer hätte ich gerne in der Klasse deklariert. Allerdings tue ich mich damit auch etwas schwer (Felder hin und her übertragen) so dass eben erst mal alles in der Main rumgammelt ;)


Bisher bin ich mit diesem Ansatz zufriedener, hab aber selbst kA, welcher der sinnvollere für diese Aufgabe ist. Vllt. habt ihr ja noch einen Denkanstoß für mich? :)

Danke erstmal bis hierher :D mfg
 
Hi.
kanonenfutter90 hat gesagt.:
Solche Funktionen wie die Addition, Umwandlung Dez <=> Dual oder auch die Stringwandlung in einen Integer hätte ich gerne in der Klasse deklariert. Allerdings tue ich mich damit auch etwas schwer (Felder hin und her übertragen) so dass eben erst mal alles in der Main rumgammelt ;)


Bisher bin ich mit diesem Ansatz zufriedener, hab aber selbst kA, welcher der sinnvollere für diese Aufgabe ist. Vllt. habt ihr ja noch einen Denkanstoß für mich? :)
Zum Vergrößern anklicken....
Also erstmal solltest du die Finger von dem Templates lassen. Lerne erstmal die Grundlagen bevor du dich an anspruchsvollere Themen wagst.

Und vergiss die Arrays in main. Damit hast du eigentlich den Sinn der Klasse völlig zunichte gemacht. Und den Speicher dynamisch zu verwalten solltest du auch lassen.

C++: 
class CBA_LongDual {
   char m_Wert[100]; // suboptimal, ein Bitfeld würde reichen

public:
   
   /** Additonsoperator
    * 
    * Damit kann man 2 CBA_LongDual Objekte addieren.
    * 
    * Das Ergebnis ist ein neues CBA_LongDual Objekt. 
    */
   CBA_LongDual operator+ (const CBA_LongDual& other) const {
      CBA_LongDual result;
      int uebertrag = 0;

      for (int i = sizeof(m_Wert)/sizeof(m_Wert) - 1; i >= 0; --i) {
          result.m_Wert[i] = (this->m_Wert[i] + other.m_Wert[i]) % 2 + uebertrag;
          uebertrag = (this->m_Wert[i] + other.m_Wert[i]) / 2;
      }
      return result;
   }
};

int main() {
  CBA_LongDual a, b;

  // Werte für a und b einlesen...
  ...

  CBA_LongDual summe = a + b;

  // summe ausgeben...
}

Gruß

PS: Wo hast du denn eigentlich die Namenskonvention her? Warum fangen deine Variablen alle mit "i" an? Hast du das in der Schule so gelernt? Variablen und Parameter schreibt man in C++ eigentlich klein.
 
Zuletzt bearbeitet:
deepthroat hat gesagt.:
PS: Wo hast du denn eigentlich die Namenskonvention her? Warum fangen deine Variablen alle mit "i" an? Hast du das in der Schule so gelernt? Variablen und Parameter schreibt man in C++ eigentlich klein.
Zum Vergrößern anklicken....

Das ist wohl so eine Art Programmierhilfe einen Buchstaben für den Datentyp (int = i, char = c usw.) vor der Variablen zu schreiben und wenn es ein Parameter ist noch ein p_ davor. Im Prinzip nicht schlecht um gleich zu erkennen worum es sich handelt, dennoch habe ich es nie so gehandhabt da mir sprechende Variablen reichen. Aber bei Style Konventionen streiten sich bekanntlich die Geister :-)
 
Danke erstmal dafür, werd das so bald wie möglich testen :)

Ja das mit den Variablen haben wir so in der Schule gelernt, der Übersicht wegen ;)
i soll also symbolisieren, dass es sich um einen Integer Wert handelt, c für char, cs für Zeichenketten etc pp.

mfg
 
kanonenfutter90 hat gesagt.:
Danke erstmal dafür, werd das so bald wie möglich testen :)

Ja das mit den Variablen haben wir so in der Schule gelernt, der Übersicht wegen ;)
i soll also symbolisieren, dass es sich um einen Integer Wert handelt, c für char, cs für Zeichenketten etc pp.
Zum Vergrößern anklicken....
Dann müßtest du das aber auch überall so machen und die Namen ständig anpassen falls du den Typ änderst. Das ist auch genau der Grund warum soetwas nicht funktioniert (meiner Meinung nach). http://de.wikipedia.org/wiki/Ungarische_Notation#Kritik

Zumal in C++ mit selbstdefinierten Typen, typedefs und Templates (wo man sowieso nicht weiß welcher Typ dahintersteht und es eigentlich auch nicht wissen möchte) diese Notation einfach nur sinnlos ist. Eine amüsante Geschichte dazu: http://www.ddj.com/cpp/184403804 :)

Gruß

PS: Oder hilft dir persönlich denn diese Notation? Da du dich nicht wirklich dran hälst scheint es dir zumindest teilweise egal zu sein...
 
Zuletzt bearbeitet:
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück