Und zwar geht es um folgendes:

Ich habe eine Klasse (HostTyp) in der in einem Datenfeld Structs (VServertyp) abgelegt werden.

In einer der Methoden soll ein Datenfeld Eintrag anhand des eingegebenen namen des VServers gelöscht werden.
Hierzu soll durch eine Hilfsfunktion im private bereich der Index des structs mit dem entsprechenden namen also funktionsresultat geliefert werden.

Hier sind die entsprechenden stellen aus dem quellcode:

Die Klasse:

class HostTyp
{
private:
int kapazitaet,groesse;
string name;
VServerTyp *Hostserver;

public:
HostTyp(int kap,string nam=" ")
:kapazitaet(0),groesse(0), name(nam);
{
Hostserver=new VServerTyp[kap];
kapazitaet=kap;
}
~HostTyp()
{
delete* Hostserver;
}

Ein beispiel für eine Remove-Funktion aus einer anderen Aufgabe

bool remove(int Index)
{
bool geht = Index<Groesse && Index>=0;
if(geht)
{
for(int i=Index; i<Groesse; ++i)
Mitglieder[i] = Mitglieder[i+1];
--Groesse;
}
return geht;
}

Jetzt hatte ich vor diese Remove funktion auf meine Aufgabe anzupassen indem ich als Indexwert die funktionsresultate nutze wobei ich mir aber auch nicht sicher bin ob es so umsetzbar ist:

bool remove(VServerTyp vst)
{
string finde;
cin>>finde;
bool geht=findVServer(vst,finde)<groesse && findVServer(vst,finde)>0;
if (geht)
{
mitglieder[findVServer(vst,finde)]=mitglieder[findVserver(vst,finde)+1];
--groesse;
}
}

Und nun mein größtes Problem
Aufgabenstellung: " Erstellen sie zusätzlich im private-Beriech eine Hilfsfunktion findVserver(), die in einem Datenfeldabgelegten VServer-Struct and Hand dessen Namens sucht und dessen index im Datenfeld als Funktionsresultat liefert.

Daraus hab ich folgendes gebaut was meiner Meinung nach nur falsch sein kann und gerne wissen würde wie ich das umsetzen kann:

int findVServer(VServerTyp vst,string suchname)
{
int p;
for(int i=0;i<groesse;++i)
{
if(Hostserver[i].servername=suchname)
p=i;
}
return p;
}

Es geht hauptsächlich im die zeile

if(Hostserver[i].servername=suchname)

Da der struct im Datenfeld abgelegt ist und ich auf eine bestimmte variable (servername) zugreifen muss habe ich das gebaut. meiner meinung nach schwachsinn

ich hoffe das war jetzt nicht zu viel und dass mir hier jemand weiterhelfen kann

ich bedanke mich schonmal im vorraus

Mit freundlichen Grüßen
isi

Aber ansonsten ist dein Code ziemlich fragwürdig. Ich würde lieber mit STL-Mitteln arbeiten als alles von Hand nachzubauen.

ich hab jetzt nochmal den kompletten quellcode überarbeitet da ich noch diverse fehlermeldungen hatte
das ganze sieht jetzt so aus:

#include <iostream>

using namespace std;

struct VServerTyp
{
  int id;
  string servername,ramkapazi,hddkapazi,ip,besitzer,anmeldename,kennwort;
};

class HostTyp
{
  private:
  int kapazitaet,groesse;
  string name;
  VServerTyp *Hostserver;

  public:
   HostTyp(int kap,string nam=" ")
   :kapazitaet(0),groesse(0), name(nam)
{
    Hostserver=new VServerTyp[kap];
    kapazitaet=kap;
}
  ~HostTyp()
  {
      delete[] Hostserver;
  }

    bool aufnehmen(VServerTyp vst)
    {

        bool geht=groesse<kapazitaet;
        if(geht)
        {
            Hostserver[groesse]=vst;
            ++groesse;
        }
        return geht;
    }

      int findVServer(VServerTyp vst,string suchname)
  {
      int p;
      for(int i=0;i<groesse;++i)
      {
          if(Hostserver[i].servername==suchname)
          p=i;
      }
      return p;
  }

    bool remove(VServerTyp vst)
    {
        string finde;
        cin>>finde;
        bool geht=findVServer(vst,finde)<groesse && findVServer(vst,finde)>0;
        if (geht)
        {
            Hostserver[findVServer(vst,finde)]=Hostserver[findVserver(vst,finde)+1];
            --groesse;
        }
        return geht;
    }
};

jetzt hab ich noch noch folgenden fehler

line 64 error: findVserver was not decleared in this scobe

Wenn du tatsächlich das Löschen von Hand erledigen willst, mußt du nicht nur den Nachfolger des zu löschenden Eintrags nach vorne verschieben, sondern alle Einträge bis zum Ende des (verwendeten) Arrays.

PS: Wirf den Zeiger über Bord und verwende lieber einen vector<VServerTyp> stattdessen.