Programmierungstechnik

Suche nach Speicherlöchern

Performance bei der Speicherbelegung

String s;
for (int i=0; i<1000; i++) {
  s.append("so'n Mist"); // Erweiterung dynamisch auf dem Heap
}

char s[1001];
for (int i=0; i<1000; i++) {
  strcat(s, "so'n Mist"); // Erweiterung auf dem stack
}

Darstellung

Rundungsfehler

Anzahl der Vorkommastellen einer Zahl berechnen

template <class T>
  long getVorkommastellen(T x) {
    x = abs(x); //log10 auf  negative Zahlen ist nicht möglich
    if(x < 1)  //log10 auf Zahlen kleiner 1 ist nicht möglich
      //0 ginge auch
      return 1;
    else 
      return long(log10(x)) +1;
  }

Aussagen über die Anzahl der Nachkommastellen einer Fließzahl

bool classA::checkNachkommastellen(double value, 
                                   const unsigned short precision) 
  {
    // zunächst Absolutwert bilden 
    if (value < 0.)
      value = -value;

    //bei mehr als 15 Stellen hab wir in double keinen Platz mehr in der
    //Mantisse und da wir überall im Server nur double nutzen und kein
    //größeres Format, würde die Funktion Quatsch berechnen
    long digits = getDigitsInFrontOfDecimalPoint(value);
    if(precision < 1 && digits == 15) 
      return true;

    digits += precision;
    if (digits > 15) 
      return false;  

    // die erlaubte Precision wird vor das Komma geschoben,
    // weil der integrale Teil immer richtig dargestellt wird haben wir 
    // hier auch keine Fehler
    value = value *  pow(10, precision);
    // der Vorkommaanteil wird abgezogen
    value = value - (double)((long long)value);
    // Ist der Wert kleiner als unsere Null-Grenze?
    return value < eps;
  }

bool classA::checkNachkommastellen(double value, 
                                   const unsigned short precision) 
  {
    double tmpVal = 0;
    static const double loge2 = log(2);

    // zunächst Absolutwert bilden 
    if (value < 0.)
      value = -value;

    // die erlaubte Precision wird vor das Komma geschoben,
    // gerundet und wieder zurueckgeschoben
    tmpVal = (long long) (value * pow(10, precision)+0.5) / 
             pow(10, precision);

    // der Vorkomma-Anteil wird abgezogen, negative Vorzeichen entfernt
    value -= tmpVal;
    if (value < 0.0)
      value = -value;

    // Der gerundete Rest muss jetzt kleiner sein als
    // die noch gueltigen Bitstellen für einen double (abzueglich
    // derer die fuer den ganzzahligen Anteil verbraten wurden) noch
    // hergeben!
    return value < pow(2, -(DBL_MANT_DIG - (int) (log(value)/loge2)));
}

1. wenn von mehrere Threads auf eine globale Variable zugegriffen wird,
2. wenn ein Thread Instanzen einer Klasse XXX mit Klassenvariablen (static) nutzt, es besteht die Gefahr des Zugriffs durch andere Threads, die Instanzen der Klasse XXX nutzen (die Klassenvariablen sind für alle gleich (gleiche Speicheradressen))
3. wenn Objektinstanzen oder Variablen von mehreren Threads referenziert werden, die Instanzen werden also erzeugt und die Speicheradressen werden an andere Threads weitergegeben.

Ein typisches Beispiel

Problem

1. Lösung

Problem der 1. Lösung

2. Lösung

ASCII

ISO-Zeichensatz

Unicode

Encoding