3. Konstruktor und seine Tücken... Initialisierung wird nicht übernommen :-/

Konstruktor und seine Tücken... Initialisierung wird nicht übernommen :-/

  • R

    Ich habe ein Problem, Denkfehler, keine Ahnung was...
    Folgenden Code habe ich:

    // meine Klasse:

class Modul{

  int byte[8];
  char c;

  public:

    Modul();
    ~Modul();

    void dez2bin(int wert);
};

// Die Definitionen:

Modul::Modul(){
  for (int k=0;k<8;k++)byte[k]=0;
};

Modul::~Modul(){}

void Modul::dez2Bin(int wert){
     cout << "\ndez2Bin aufgerufen mit wert: "<<wert<<endl;

     if (wert <0 || wert>255) wert=255;
     byte[7]=wert%2; wert=wert/2;
     byte[6]=wert%2; wert=wert/2;
     byte[5]=wert%2; wert=wert/2;
     byte[4]=wert%2; wert=wert/2;
     byte[3]=wert%2; wert=wert/2;
     byte[2]=wert%2; wert=wert/2;
     byte[1]=wert%2; wert=wert/2;
     byte[0]=wert%2;
     for (int u=0;u<8;u++) cout<<byte[u]<<endl;
}

    Wenn ich von außerhalb die Funktion dez2bin mit einen beliebigen Wert aufrufe, so werden die Zahlen nicht in das Byte Array der Klasse geschrieben.
    Was ist falsch?

    0
  • C

    Dieser Thread wurde von Moderator/in Jansen aus dem Forum Borland C++ Builder (VCL/CLX) in das Forum C++ verschoben.

    Im Zweifelsfall bitte auch folgende Hinweise beachten:
    C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

    Dieses Posting wurde automatisch erzeugt.

    0
  • L

    void dez2bin(int wert) != void Modul::dez2Bin(int wert)

    TIPP: achte auf die groß- und kleinschreibung...

    //edit:

    die variablen in einer schleife heißen eigentlich i oder j... und du musst nicht bei den schleifen unterschiedliche variablen nehmen.... nur noch so ein tipp 😉

    0
  • M

    hab die klasse mal getestet ... bis auf den fehler mit der groß/klein schreibung hat alles wunderbar funktioniert .. hab die ausgabe allerdings nicht ueber cout gemacht .. ich hab gleich mitm debugger geguckt ..

    allerdings is die deztobin funktion etwas umstaendlich .. ich wuerd das lieber so machen ...

    void Modul::dez2Bin(int wert){
     if (wert <0 || wert>255) wert=255;
     for(int i=7;i>=0;i--) {
        byte[i]=wert&1;
        wert>>=1;
     }
}
    0
  • G

    Noch ein Tipp am Rande. Für genau solche Sachen

    wert=wert/2;

    gibt es die vielen Assignment Operatoren. Daraus wird dann

    wert/=2;

    Auch wenn dir die Syntax etwas ungewohnt vorkommt, du solltest dir generell angewöhnen das zu benutzen. Bei builtin Typen bringt das noch nicht viel, bei externen Klassen allerdings schon, da die Assignment Operatoren performanter implementiert werden können.

    0
  • R

    Antworten über Antworten, danke.
    Die Groß- Kleinschreibungsgeschichte hab ich beim Übertragen des Codes reingehauen.
    Hab ich also im Programm richtig.
    Ich hacke jetzt nochmal alles neu ein,
    vielleicht hab ich noch an einer anderen Stelle einen Fehler.

    Trozdem vielen Dank!

    Raptor

    0
  • ?

    Performanter wäre

    for(int *p = &byte[7]; p >= b; --p) {
  *p = wert & 1;
  wert >>= 1;
}

    Oder auch, hässlich aber performant:

    byte[7] = wert &   1;
byte[6] = wert &   2;
byte[5] = wert &   4;
byte[4] = wert &   8;
byte[3] = wert &  16;
byte[2] = wert &  32;
byte[1] = wert &  64;
byte[0] = wert & 128;

    ...oder, wenn mans ganz hart durchziehen will:

    class Modul{
private:
  int byte[8];

  template<int i> inline void byte_helper_loop    (int wert) {
    byte[i] = (wert << 7 - i) & 1;
    byte_helper_loop<i-1>(wert);
  }
  template<>      inline void byte_helper_loop<-1>(int wert) { }

public:

  Modul();
  ~Modul();

  void dez2bin(int wert);
};

// Die Definitionen:

Modul::Modul(){
  for (int k=0;k<8;k++)byte[k]=0;
};

Modul::~Modul(){}

void Modul::dez2Bin(int wert){
  if (wert <0 || wert>255) wert=255;
  byte_helper_loop<7>(wert);
}

    Wobei ich das im Zweifel eh noch ganz anders anfangen würde, etwa so:

    class Modul {
public:
  typedef unsigned type;

private:
  type x;

public:
  void assign(type zahl) { x = zahl; }
  int operator()(int index) { return x & (1 << index); }
};

//...

Modul m;
m.assign(1234);
for(int i = 0; i < sizeof(Modul::type) * 8; ++i)
  std::cout << m(i);
std::cout << std::endl;

    Sowas in der Art halt.

    0
  • R

    Noch ein Hinweis.
    Mit der Klasse möchte ich ein I²C EEprom beschreiben.
    Das funktioniert auch fast. Hab gerade nochmal alles getestet. Solange ich kein EEPROM dran habe, läufts 100%ig. Ist das Ding angeschlossen, wurschtelt mir das das byte Array durcheinander, und ich habe unlogische Werte drin...

    0
  • G

    @0xdeadbeef
    Du bist gemein, erschlage Raptor2000 doch nicht gleich mit Template Meta Programming. 😃

    0
  • ?

    Ach, das bisschen... 😃

    0
  • R

    Das Problem liegt woanders, ich schätze mal in der Verwendung einer dll...
    vermutlich macht die mir murks und schreibt fröhlich auf irgendwelche Adressen.
    Daher bekomm ich auch hin und wieder komische Zugriffschutzverletzungen.
    Nur kann mein scheiss Borland Compiler (bzw ich 😉 )
    nicht vernünftig debuggen 😕

    0
Anmelden zum Antworten