Lebenszeit und -ort eines Objekts

Content

Objekte können global bzw. statisch, lokal auf dem Stack oder auf dem Heap leben. Ihre Lebenszeit ist entsprechend. Zusätzlich gibt es auch noch thread_local-Deklarationen für Objekte, deren Lebenszeit mit der eines Threads verbunden sind. Damit beschäftigen wir uns aber noch nicht im Rahmen dieser Sitzung.

Globale bzw. statische Variablen

Bei globalen bzw. statischen Variablen steht die Adresse beim Zusammenbau des Programms bereits fest (daher statisch im Gegensatz zu dynamisch, d.h. zur Laufzeit). Entsprechende Objekte werden vor dem Aufruf von main konstruiert und nach dem Ende von main bzw. dem Aufruf von exit abgebaut. Eine Ausnahme davon sind mit static deklarierte Objekte innerhalb einer Funktion oder Methode. Diese werden erst konstruiert, wenn die Ausführung die entsprechende Deklaration das erste Mal erreicht. Dies ist seit C++11 auch thread-safe.

Alle Deklarationen sind im folgenden Beispiel global bzw. statisch:

#include <iostream>

class X {
   private:
      const char* name;
   public:
      X(const char* name) : name(name) {
	 std::cout << "X \"" << name << "\" constructed" << std::endl;
      }
      ~X() {
	 std::cout << "X \"" << name << "\" destructed" << std::endl;
      }
};

class Y {
   static X x; // static member, defined below
};

X Y::x = "static member of Y"; // definition of Y::x

X x = "global variable";

int main() {
   std::cout << "main starts" << std::endl;
   static X x = "static variable within main";
   std::cout << "main ends" << std::endl;
}
theon$ g++ -Wall -o global global.cpp
theon$ ./global
X "static member of Y" constructed
X "global variable" constructed
main starts
X "static variable within main" constructed
main ends
X "static variable within main" destructed
X "global variable" destructed
X "static member of Y" destructed
theon$ 

Es ist hier wiederum zu beobachten, dass alle Objekte in umgekehrter Reihenfolge abgebaut werden. Das ist bei innerhalb einer Funktion oder Methode statisch deklarierten Variablen nicht trivial umzusetzen, da die Reihenfolge der Konstruktionen nicht vorhersehbar ist:

#include <iostream>

class X {
   private:
      const char* name;
   public:
      X(const char* name) : name(name) {
	 std::cout << "X \"" << name << "\" constructed" << std::endl;
      }
      ~X() {
	 std::cout << "X \"" << name << "\" destructed" << std::endl;
      }
};

void foo(int selector) {
   if (selector) {
      static X x1 = "x1 within foo";
   }
   static X x2 = "x2 within foo";
}

int main() {
   std::cout << "main starts" << std::endl;
   int selector;
   if (std::cin >> selector) {
      foo(selector); foo(1);
   }
   std::cout << "main ends" << std::endl;
}
theon$ g++ -Wall -o static-can-be-dynamic static-can-be-dynamic.cpp
theon$ echo 0 | ./static-can-be-dynamic
main starts
X "x2 within foo" constructed
X "x1 within foo" constructed
main ends
X "x1 within foo" destructed
X "x2 within foo" destructed
theon$ echo 1 | ./static-can-be-dynamic
main starts
X "x1 within foo" constructed
X "x2 within foo" constructed
main ends
X "x2 within foo" destructed
X "x1 within foo" destructed
theon$ 

Lokale Variablen

Wenn die Programmausführung eine lokale Variablendeklaration erreicht, wird diese konstruiert. Am Ende des umgebenden Blocks (das ist das umgebende compound statement) werden die lokalen Variablen in umgekehrter Reihenfolge wieder abgebaut. Alle lokalen Variablen leben in dem entsprechenden Stack-Segment, das dem Funktionsaufruf zugeordnet ist.

#include <iostream>

class X {
   private:
      const char* name;
   public:
      X(const char* name) : name(name) {
	 std::cout << "X \"" << name << "\" constructed" << std::endl;
      }
      ~X() {
	 std::cout << "X \"" << name << "\" destructed" << std::endl;
      }
};

int main() {
   for (int i = 0; i < 2; ++i) {
      X x1 = "x1 within for loop";
      {
	 X x2 = "x1 in the inner block";
	 X x3 = "x2 in the inner block";
      }
      X x4 = "x4 at the end of the for loop";
   }
}
theon$ g++ -Wall -o local local.cpp
theon$ ./local
X "x1 within for loop" constructed
X "x1 in the inner block" constructed
X "x2 in the inner block" constructed
X "x2 in the inner block" destructed
X "x1 in the inner block" destructed
X "x4 at the end of the for loop" constructed
X "x4 at the end of the for loop" destructed
X "x1 within for loop" destructed
X "x1 within for loop" constructed
X "x1 in the inner block" constructed
X "x2 in the inner block" constructed
X "x2 in the inner block" destructed
X "x1 in the inner block" destructed
X "x4 at the end of the for loop" constructed
X "x4 at the end of the for loop" destructed
X "x1 within for loop" destructed
theon$ 

Variablen auf dem Heap

Daten können auf dem Heap mit dem new-Operator angelegt werden. Mit delete werden sie zunächst dekonstruiert und danach wird der belegte Speicher freigegeben. Bei einem Speicherleck, d.h. dem Fehlen von delete kommt es nicht zum Abbau der entsprechenden Objekte. Solche Speicherlecks können mit Hilfe des Werkzeugs valgrind festgestellt werden.

      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
#include <iostream>

class X {
   private:
      const char* name;
   public:
      X(const char* name) : name(name) {
	 std::cout << "X \"" << name << "\" constructed" << std::endl;
      }
      ~X() {
	 std::cout << "X \"" << name << "\" destructed" << std::endl;
      }
};

int main() {
   X* x1p = new X{"*x1p"};
   X* x2p = new X{"*x2p"};
   delete x1p;
}
theon$ g++ -Wall -Wno-unused-variable -g -o heap heap.cpp
theon$ ./heap
X "*x1p" constructed
X "*x2p" constructed
X "*x1p" destructed
theon$ valgrind ./heap
==25562== Memcheck, a memory error detector
==25562== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==25562== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==25562== Command: ./heap
==25562== 
X "*x1p" constructed
X "*x2p" constructed
X "*x1p" destructed
==25562== 
==25562== HEAP SUMMARY:
==25562==     in use at exit: 5,136 bytes in 2 blocks
==25562==   total heap usage: 4 allocs, 2 frees, 77,848 bytes allocated
==25562== 
==25562== LEAK SUMMARY:
==25562==    definitely lost: 8 bytes in 1 blocks
==25562==    indirectly lost: 0 bytes in 0 blocks
==25562==      possibly lost: 5,128 bytes in 1 blocks
==25562==    still reachable: 0 bytes in 0 blocks
==25562==         suppressed: 0 bytes in 0 blocks
==25562== Rerun with --leak-check=full to see details of leaked memory
==25562== 
==25562== For counts of detected and suppressed errors, rerun with: -v
==25562== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
theon$ valgrind --leak-check=full ./heap
==25573== Memcheck, a memory error detector
==25573== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==25573== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==25573== Command: ./heap
==25573== 
X "*x1p" constructed
X "*x2p" constructed
X "*x1p" destructed
==25573== 
==25573== HEAP SUMMARY:
==25573==     in use at exit: 5,136 bytes in 2 blocks
==25573==   total heap usage: 4 allocs, 2 frees, 77,848 bytes allocated
==25573== 
==25573== 8 bytes in 1 blocks are definitely lost in loss record 1 of 2
==25573==    at 0xFFFB03A44: operator new(unsigned long) (vg_replace_malloc.c:358)
==25573==    by 0x400C15: main (heap.cpp:17)
==25573== 
==25573== 5,128 bytes in 1 blocks are possibly lost in loss record 2 of 2
==25573==    at 0xFFFB038A7: malloc (vg_replace_malloc.c:311)
==25573==    by 0xFFF8D6FEC: _findbuf (in /lib/amd64/libc.so.1)
==25573==    by 0xFFF8D7216: _wrtchk (in /lib/amd64/libc.so.1)
==25573==    by 0xFFF8DBC97: _fwrite_unlocked (in /lib/amd64/libc.so.1)
==25573==    by 0xFFF8DBBE4: fwrite (in /lib/amd64/libc.so.1)
==25573==    by 0xFFF718684: sputn (streambuf:451)
==25573==    by 0xFFF718684: __ostream_write > (ostream_insert.h:50)
==25573==    by 0xFFF718684: std::basic_ostream >& std::__ostream_insert >(std::basic_ostream >&, char const*, long) (ostream_insert.h:101)
==25573==    by 0xFFF7189C7: std::basic_ostream >& std::operator<<  >(std::basic_ostream >&, char const*) (ostream:561)
==25573==    by 0x400D25: X::X(char const*) (heap.cpp:8)
==25573==    by 0x400C07: main (heap.cpp:16)
==25573== 
==25573== LEAK SUMMARY:
==25573==    definitely lost: 8 bytes in 1 blocks
==25573==    indirectly lost: 0 bytes in 0 blocks
==25573==      possibly lost: 5,128 bytes in 1 blocks
==25573==    still reachable: 0 bytes in 0 blocks
==25573==         suppressed: 0 bytes in 0 blocks
==25573== 
==25573== For counts of detected and suppressed errors, rerun with: -v
==25573== ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)
theon$ 

Aufgaben