3. string-array erstellen aber mit char*

string-array erstellen aber mit char*

  • S

    hallo community,
    also ich benutzt den devc++ compiler und dort ist es nicht möglich string als datentyp zu verwenden.
    Daher benutzt ich char* var;
    was eigentlich das selbe ist
    nunja jetzt möchte ich aber ein stringarray erstellen und das dann dynamisch erweiteren

    also habe ich mir gedacht mache folgendes:
    char *menuPunkt[0]; //einzelne Menüpunkte

    dann habe ich eine methode in meiner klasse, die einen neuen menüpunkt erzeugt

    /***| neuer Menüpunkt |*/
    void Cmenu::set_menupunkt(char     punkt)
    {
    anzMenupunkt++;
    menuPunkt[anzMenupunkt]=(char    ) malloc((strlen(punkt)+1)*sizeof(char));
    }

    aber irgendwie funktioniert das nicht so.

    ich will halt, dass wenn ich einen neuen menupunkt erstellen ein neuer index dazu kommt
    aber halt alles dynamisch, damit der speicherplatz klein bleibt
    hoffe ihr versteht mein anliegen, bekomme hie rnoch ne krise:)

    danke für jede antwort

    bye

    0
  • C

    nimm std::vector, das erspart dir viel Zeit und Arbeit 😉

    #include <vector>

std::vector<char*> menuepunkte;

//...

void neuerMenupunkt(char* punkt) {
  menuepunkte.push_back(punkt); 
}
    0
  • .

    swissboy schrieb:

    hallo community,
    also ich benutzt den devc++ compiler und dort ist es nicht möglich string als datentyp zu verwenden.

    Dev-C++ ist eine IDE, kein Compiler. Der ist wahrscheinlich MinGW und hat (wie jeder C++-Compiler) sehr wohl einen "Datentyp" für Strings, wenn auch nicht fest eingebaut. Du musst dafür den entsprechenden Header mit "#include <string>" einbinden, dann steht dir std::string mit all seinen Bequemlichkeiten zur Verfügung.

    Zu Menüs: http://www.c-plusplus.net/forum/viewtopic-var-t-is-152690.html

    Lern mal fleißig weiter C++ (!) und schau dir die Standardbibliothek genauer an.

    0
  • S

    ich glaube ihr versteht nicht mein problem
    das mit den strings ist ja egal
    da gibt es haufen mthoden die zumachen
    mir geht es um die speichererweiterung.
    damit haut es nicht ganz hin
    ich habe am anfang nur ein index
    aber bei jedem neuen menüpunkt soll ein index dazu kommen

    hoffe wisst wie ich das meine

    byee

    0
  • L

    Erstens: Dein Array ist null Elemente lang - da passt nichtmal ein String rein (auch wenn Du für den String selbst noch so viel Speicher reservierst).
    Zweitens: Es ist garantiert, dass sizeof(char) eins ist.
    Drittens: In C++ nimmt man new/delete (und in C castet man den Rückgabewert von malloc nicht)

    Wenn Du auf dem Gewurschtel bestehst, musst Du vorher für den Array selbst Speicher reservieren, und dann für jedes Element nochmal:

    char** menuPunkt = 0;
int anzMenuPunkt = 0;

{
  char** newMenuPunkt = new char*[ anzMenuPunkt + 1 ];
  std::copy( menuPunkt, menuPunkt + anzMenuPunkte, newMenuPunkt );
  menuPunkt[ anzMenuPunkt ] = new char[ std::strlen( punkt ) + 1 ];
  std::strcpy( menuPunkt[ anzMenuPunkt ], punkt );
  delete[] menuPunkt;
  menuPunkt = newMenuPunkt;
  ++anzMenuPunkt;
}

    Aber std::string und std::vector machen die Sache bissi einfacher 😉

    0
  • *

    Hmm das ist immer ein widerliches Zeigergeschubse...

    naja ... es geht aber so:

    class CMenu 
{
public:
    void                        AddItem(const char* const);

private:
    char**			m_ppszItems;
    unsigned short	        m_nItemCount;
//...
}

    CMenu::CMenu(void) : m_nItemCount(0), m_ppszItems(NULL)
{
}

CMenu::~CMenu(void)
{
    if (m_ppszItems != NULL)
    {
        delete [] m_ppszItems;
        m_ppszItems = NULL;
    }

    m_nItemCount = 0;
}

    So ... damit haben wie eine Variable die die Anzahl der Items zählt und eine die auf die zeigt ... im Destruktor räumen wir halt wieder auf ...

    void CMenu::AddItem(const char* const lpszItem)
{
	char** ppszTmp = NULL; // Temp char pointer pointer

	if (m_ppszItems != NULL) // Haben wir schon Items?
	{
		ppszTmp = new char*[m_nItemCount]; // ja also tmp genauso groß wie den momentanen machen ...
		memcpy(ppszTmp, m_ppszItems, sizeof(char*) * m_nItemCount); // alles rüberkopieren
	}

	delete [] m_ppszItems; // den alten löschen
	m_ppszItems = new char*[m_nItemCount + 1]; // einen um 1 größeren erstellen

	if (ppszTmp != NULL) // wenn schon items da waren diese jetzt wieder reinkopieren
		memcpy(m_ppszItems, ppszTmp, sizeof(char*) * m_nItemCount);

	delete [] ppszTmp; // tmp wieder freigeben 

	unsigned int nLen		= (unsigned int)lstrlen(lpszItem) + 1; // die länge des hinzuzufügenden char-arrays ermitteln (+ 1 für '\0')
	m_ppszItems[m_nItemCount]	= new char[nLen]; // nen char array mit dieser größe anlegen
	memcpy(m_ppszItems[m_nItemCount], lpszItem, nLen); // da dann den string im mem reinkopieren ...

	++m_nItemCount;
}

    Damit wird nen Item hinzugefügt...

    [edit] 😡 zu spät 😞 [/edit]

    0
Anmelden zum Antworten