wie könnte man eine klasse gestalten

also ich will ein bisschen (viel) mehr zum thema objektorientierung lernen.
nun finde ich dieses thema ziemlich kompliziert und ich wollte nun mal fragen wie bei euch eine klasse aussehen müsste bzw wie ihr an dieses thema herangeht wenn ihr eine erstellen wollt. mein ziel ist es für das untere beispiel (mein noch nicht fertiges projekt) eine klasse zu erstellen die einen abstrakten datentyp(hoffe doch das man das so nennt) beinhaltet. dieser soll den sehr oft verwendeteten

vector<char>

beinhalten.
wie würde nun eigentlich eine klasse aussehen? die implementation interssiert mich natürlich weniger (wäre ja auch frevelhaft danach zu fragen )

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <iostream>
#include <cstdlib>
#include <vector>
#include <stack>
#include <strstream>
#include <cstdlib> 
#include <stdio.h>
#include <iomanip>

using namespace std;

//Ã¶ffentliche Variablen
int pos_gziffer = 0;
int pos_vorgzahl = 0;
short pos_klammer_a;
short pos_klammer_z;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

long double ziffer(char c) {
  long double zahl = static_cast<long>(c) - static_cast<long>('0');
  return zahl;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

vector<char> erase(const vector<char> vc, int a, int b) {
  vector<char> ausgabe;

  for(int x = 0; x < vc.size(); x++) {
    if(!(x >= a && x <= b))
     ausgabe.push_back(vc[x]);
}

return ausgabe;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

long double gziffer(vector<char> vc, int pos, bool ermtl_pos) { 
  int d = 0, x = 0;
  long double p = 1; //fÃŒr kommastellen und potenzen '10e+9'
  unsigned long long q = 10; //fÃŒr kommazahlen
  long double zerg = 0;
  int negcounter = 0;

  bool is_nega = false;
  bool is_deca = false;
  bool is_pot = false;

  vc.erase(vc.begin(), vc.begin()+pos);  //lÃ¶scht die ersten n elemente eines vectors ==> deque verwenden fÃŒr vs.:0.2

  if(vc.size() > 1) {
    is_nega = ((vc[0] == '-')? true : false);  //Bedingungsoperator 
    negcounter++;
  }

  if(!isdigit(vc[x])) {
    vc.erase(vc.begin(), vc.begin()+1); //unbedingt verbessern
    pos++;
    }

  for(int z = 0; z < vc.size() && isdigit(vc[z])
                 || vc[z] == 'e' || vc[z] == '.'; z++) {
    if(vc[z] == '.') {
      is_deca = true;
      d = z + 1;
    }
    if(vc[z] == 'e' && vc[z+1] == '+' || vc[z+1] == '-') {
      is_pot = true;
      p = z + 2;
    }
  }

  while(x < vc.size()) { 
    if(isdigit(vc[x])) 
      zerg = zerg * 10 + ziffer(vc[x]);
    ++x;

    if(ermtl_pos == true)
      pos_gziffer = x + (pos - 1);

    if(!isdigit(vc[x]))
      break;
  }

  while(d < vc.size() && is_deca == true) {
    if(isdigit(vc[d])) {
      long double f = ziffer(vc[d]);
      f = f / q;     
      zerg = zerg + f;
    }
    //////////////////
    ++d;
    if(ermtl_pos == true)
      pos_gziffer = d + pos - 1;
    q = q * 10;
    //////////////////

    if(!isdigit(vc[d]))
      break;
  } 

  if(is_nega) zerg *= (-1); 

  cout<<"gziffer"<<pos_gziffer<<endl;
  return zerg; 
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

vector<char> zahl_char(long double zahl) {

  strstream lengthChecker;
  lengthChecker.width(15);
  lengthChecker << zahl ;//<< '\0'; // Nullterminierung ist wichtig
  string zahlStr = lengthChecker.str();  

  char temp_vec_char[zahlStr.length()];
  vector<char> vec_char;

  gcvt( zahl, zahlStr.length(), temp_vec_char );
  for(int x = 0; x <= zahlStr.length(); x++) {

    if(temp_vec_char[x] >= '0' && temp_vec_char[x] <= '9' 
      || temp_vec_char[x] == '-' || temp_vec_char[x] == '.') //wie isdigit() nur erweitert

      vec_char.push_back(temp_vec_char[x]);
  }

  return vec_char;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

long double vorgzahl(vector<char> vc, int pos_sign) {

  int x = (pos_sign - 1);

  while(isdigit(vc[x]) && x != 0 || vc[x] == '.')
    x--;

  pos_vorgzahl = x;
  if(pos_vorgzahl > 0)
    pos_vorgzahl++;

  return gziffer(vc, x, false); //verÃ€nder pos_gziffer, spÃ€ter Ã€ndern !!!
}
//////////////////////////////////////////////Hilfsfunktion/////////////////////////////////////////////////////////////////////

long double mdas_rechnung(vector<char>& vc) {

  bool r_f_add;
  long double temp_var;

  for(int x = 0; x < vc.size(); x++) {

    if(vc[x] == '*') {

      temp_var = vorgzahl(vc, x) * gziffer(vc, x, true); //x+1  in gziffer Ã€ndern
      cout<<"vorG "<<vorgzahl(vc, x)<<endl<<"NACH "<<gziffer(vc, x, true)<<endl;
      if(temp_var >= 0)
        vc = erase(vc, pos_vorgzahl, pos_gziffer);
      else{ pos_vorgzahl -= 1;
      vc = erase(vc, pos_vorgzahl, pos_gziffer);
      }

        for(int y = zahl_char(temp_var).size()-1; y >= 0; y--) {
          vc.insert(vc.begin()+pos_vorgzahl, zahl_char(temp_var)[y]);
	  x = 0;
        }
    }

    if(vc[x] == '/') {//fehler, kommazahlen kÃ¶nnen nicht interpretiert werden

      temp_var = vorgzahl(vc, x) / gziffer(vc, x, true); //x+1  in gziffer Ã€ndern
      if(temp_var >= 0)
        vc = erase(vc, pos_vorgzahl, pos_gziffer);
      else{ pos_vorgzahl -= 1;
      vc = erase(vc, pos_vorgzahl, pos_gziffer);
      }

        for(int y = zahl_char(temp_var).size()-1; y >= 0; y--) {
          vc.insert(vc.begin()+pos_vorgzahl, zahl_char(temp_var)[y]);
	  x = 0;
        }
    }

    //********************************//ÃœberprÃŒfung wann er addieren kann: ANFANG
    for(int x = 0; x < vc.size(); x++) {
      int y = 0;

      if(x == '*' || x == '/')
        y++;
      if(y == 0)
        r_f_add = false;
      else r_f_add = true;
    }
    //********************************//ENDE 
  }

  for(int x = 0; x < vc.size(); x++) {

    if(vc[x] == '+' || vc[x] == '-' && r_f_add == false) {     
      temp_var = vorgzahl(vc, x) + gziffer(vc, x, true);
      vc = erase(vc, pos_vorgzahl, pos_gziffer);

        for(int y = zahl_char(temp_var).size()-1; y >= 0; y--) {
          vc.insert(vc.begin()+pos_vorgzahl, zahl_char(temp_var)[y]);
	  x = 0;
        }
    }

  }

for(int k = 0; k < vc.size(); k++)
cout<<"pos"<<k<<" "<<vc[k]<<endl;

  return temp_var; 
}

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

int main(int argc, char *argv[])
{
  cout.precision(13);

  char eingabe;
  vector<char> veingabe;

  while(true) {
    cin.get(eingabe);
    if(eingabe != 'e')
      veingabe.push_back(eingabe);
    else break;
  }

  cout<<mdas_rechnung(veingabe); 

  return EXIT_SUCCESS;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Walli

EDIT: Ach so, jetzt weiß ich was du meinst. An deiner Stelle würde ich zuerst mal ein gutes Tutorial ansehen. Du findest gute über die Hauptseite.

Wie man zu Klassen kommt und wie man sie designt, darauf kann es wohl keine Standardantwort geben. Lies mal die Links die ich gepostet habe.
Das ist keine direkte Lösung für dein Problem, doch es ist Grundwissen mit dem du da versorgt wirst. Das hilft dir vielleicht allgemeineres Verständnis zu bekommen.
Ein gutes Buch ist da sicherlich hilfreich.

http://www.wi-bw.tfh-wildau.de/~hendrix/grundstudium/cpp/skript/entwurfstechniken.html

http://www.c-plusplus.net/cms/modules.php?op=modload&name=Downloads&file=index&req=viewdownloaddetails&lid=17

ich habe ein lehrbuch und ich würde sagen das ich z.teil viele sachen verstanden habe, allerdings ist dieses buch SEHR , ich nenn es mal, abstrakt...

thx für die links und answers

volkard

gnupi schrieb:

ich habe ein lehrbuch und ich würde sagen das ich z.teil viele sachen verstanden habe, allerdings ist dieses buch SEHR , ich nenn es mal, abstrakt...

besorg dir ein lehrbuch, wo drin steht, wie man andere lehrbücher fachgerecht verbrennt.

thx für die links und answers

die bringen dir nix.
zuerst lies die anfängertutorials *nochmal* durch.
dann besorg die "effektiv c++ programmieren" und arbeite es durch.
und wenn du irgendwann die durchschnittliche zeilenzahl pro funktion auf unter 10 hast, wenn du globale variablen meidest, wenn du deinem compiler vertraust,
wenn du dir hilfsfunktionen für einmaleige verwendung schreibst um deinen code zu vereinfachen, wenn du sprüche wie "is_nega = ((vc[0] == '-')? true : false);" unterläßt, wenn du laufbedingungen aus vier! teilbedingungen nich mehr machst, ...
(hab erst den ersten bildschirm genauer angeguckt. hab keine lust mehr.)

...dann können wir drüber reden, daß du mit c++ anfängt.

im moment ist dein stil so fürchterlich, daß du auf keinen fall klassen und so entwerfen solltest, du würdest dir einen fürchterlichen entwurfs-stil aneignen (der vom katastrophalen programmierstil influiert wird).

das ist irgendwie weniger aufbauend... aber ich sollte wirklich etwas überschaubarer gestalten