C++: Heap/Stack

[Andre (Gast)]

Hallo,

ich spiel gerade etwas mit C++ herum und bin zum Thema dynamische 
Speicherverwaltung gekommen.

Ich habe folgendes Konstrukt:

#include <iostream>
#include "A.h"
#include "B.h"
using namespace std;

int main() {

  /* Both objects on Stack */

  A classAStack;
  B classBStack;


  /* Both objects on Heap*/
//  A *classAHeap = new A();
//  B *classBHeap = new B();

  /* A objects on Heap B ???*/
  A *classAHeap = new A();


  return 0;
}

#ifndef A_H_
#define A_H_
#include <iostream>
#include "B.h"

class A {
public:
  A();
  virtual ~A();


public:
  B b;

};

#endif /* A_H_ */


#include "A.h"


A::A() {
  std::cout <<"Constructor A called" << std::endl;
}

A::~A() {
}

#ifndef B_H_
#define B_H_
#include <iostream>

class B {
public:
  B();
  virtual ~B();
};

#endif /* B_H_ */


#include "B.h"

B::B() {
  std::cout <<"Constructor B called" << std::endl;
}
B::~B() {
}

Die Ausgabe des Debuggers sieht wie folgt aus:

Temporary breakpoint 6, main () at ../src/HeapStackTest02.cpp:18
18    A classAStack;

Breakpoint 4, B::B (this=0x23aa58) at ../src/B.cpp:12
12    std::cout <<"Constructor B called" << std::endl;

Breakpoint 5, A::A (this=0x23aa50) at ../src/A.cpp:13
13    std::cout <<"Constructor A called" << std::endl;

Breakpoint 4, B::B (this=0x23aa40) at ../src/B.cpp:12
12    std::cout <<"Constructor B called" << std::endl;

Breakpoint 4, B::B (this=0x60004b048) at ../src/B.cpp:12
12    std::cout <<"Constructor B called" << std::endl;

Breakpoint 5, A::A (this=0x60004b040) at ../src/A.cpp:13
13    std::cout <<"Constructor A called" << std::endl;

Breakpoint 1, main () at ../src/HeapStackTest02.cpp:30
30    return 0;


Nun zu meiner Frage:
Wo liegt die Member-Variable b der Klasse A?
Wenn ich mir die Adressen ansehe scheint der Adressbereich 0x23a... der 
Stack zu sein und 0x6000.... der Heap.
Ich arbeite auf einem Windows 64Bit System.
Warum liegt die Member-Variable auch auf dem Heap ohne, dass ein new 
Operator benutz worden ist.

Danke,
Andre

[Noch einer (Gast)]

Ziel von C++ ist -- die Programme sollen genau so performant wie 
Assemblerprogramme sein. Dafür mutet man dem Programmierer einige Knoten 
in den Gedankengängen zu.

Es wird halt schneller, wenn "new A()" nur einmal Speicherbereich für 
alles reservieren muss.

Im laufe der Zeit gewöhnst du dich an diese Sachen.

[Sebastian V. (sebi_s)]

Andre schrieb:
> Warum liegt die Member-Variable auch auf dem Heap ohne, dass ein new
> Operator benutz worden ist.

Ich nehme an du meinst das letzte B Objekt, denn die anderen B Objekte 
sind ja auf dem Stack. Der Grund ist einfach, dass dein A Objekt auf dem 
Heap liegt und damit liegen alle Membervariablen auch auf dem Heap. Die 
Membervariablen ist ja gerade das was dein Objekt ausmacht.

[M.K. B. (mkbit)]

Für die Anwendung reicht die Vorstellung von sebi_s vollkommen aus. Ein 
Objekt liegt da, wo man es angelegt hat, also auch seine 
Membervariablen.

Ich will hier noch ein bisschen ins Detail gehen, was im Speicher 
passiert.

Ein Objekt besteht aus Membervariablen, die Speicherplatz brauchen. Die 
Größe des Objektes entspricht der Summe der Membervariablen. (Es kommen 
aber auch noch "versteckte" Größen für alignment oder vtable dazu, auf 
die ich hier aber nicht weiter eingehen möchte.)

Will man jetzt ein Objekt anlegen, dann wird dieser Speicherplatz 
entweder auf dem Stack angelegt oder über new/malloc auf dem heap. Das 
Objekt wird dabei über seine Startadresse angesprochen. Die Variablen 
liegen dann jeweils an einem Offset von der Startadresse, der von der 
Struktur des Objektes abhängt.

Beim Zugriff auf dem Objekt ist dann nur noch die Speicheradresse 
relevant, ob diese auf dem Heap oder Stack liegt ist dabei egal, 
Speicher ist Speicher.