frage zu strukturen bzw klassen

[bernd G]

Im folgenden Code, werden Strukturen wie Klassen behandeltn mit Konstruktor und Destruktor, seit wann hat denn eine Struktur einen Konstruktor? Ich dachte genau das waere ein Unterschied zw. Klassen und Strukturen.

Und, in der Struktur auto_ptr_data
versteh ich den code nicht:
existing(bool& s) : s_(s){ s_ = true; };
das nach dem doppelpunkt sieht aus wie ne Initialisieringsliste, derweil, ist doch s_ nur eine einfache Bool Variable!?

#include <tut.h>
#include <set>
#include <memory>

/**
 * This example test group tests std::auto_ptr implementation.
 * Tests are far from full, of course.
 */
namespace tut
{
  /**
   * Struct which may contain test data members.
   * Test object (class that contains test methods)
   * will inherite from it, so each test method can
   * access members directly.
   *
   * Additionally, for each test, test object is re-created
   * using defaut constructor. Thus, any prepare work can be put
   * into default constructor.
   *
   * Finally, after each test, test object is destroyed independently
   * of test result, so any cleanup work should be located in destructor.
   */
  struct auto_ptr_data
  { 
    /**
     * Type used to check scope lifetime of auto_ptr object.
     * Sets extern boolean value into true at constructor, and
     * to false at destructor.
     */
    bool exists;
    struct existing
    {
      bool& s_;
      existing(bool& s) : s_(s){ s_ = true; };
      ~existing(){ s_ = false; };
    };
  };

  /**
   * This group of declarations is just to register
   * test group in test-application-wide singleton.
   * Name of test group object (auto_ptr_group) shall
   * be unique in tut:: namespace. Alternatively, you
   * you may put it into anonymous namespace.
   */
  typedef test_group<auto_ptr_data> tf;
  typedef tf::object object;
  tf auto_ptr_group("std::auto_ptr");

  /**
   * Checks default constructor.
   */
  template<>
  template<>
  void object::test<1>()
  {
    std::auto_ptr<existing> ap;
    ensure(ap.get()==0);
    ensure(ap.operator->()==0);
  }

  /**
   * Checks constructor with object
   */
  template<>
  template<>
  void object::test<2>()
  {
    {
      std::auto_ptr<existing> ap(new existing(exists));
      ensure("get",ap.get()!=0);
      ensure_equals("constructed",exists,true);
    }
    // ptr left scope
    ensure_equals("destructed",exists,false);
  }

  /**
   * Checks operator -> and get()
   */
  template<>
  template<>
  void object::test<3>()
  {
    std::auto_ptr<existing> ap(new existing(exists));
    existing* p1 = ap.get();
    existing* p2 = ap.operator->();
    ensure("get equiv ->",p1==p2);
    // ensure no losing ownership
    p1 = ap.get();
    ensure("still owner",p1==p2);
  }

  /**
   * Checks release()
   */
  template<>
  template<>
  void object::test<4>()
  {
    {
      std::auto_ptr<existing> ap(new existing(exists));
      existing* p1 = ap.get();
      std::auto_ptr<existing> ap2(ap.release());
      ensure("same pointer",p1==ap2.get());
      ensure("lost ownership",ap.get()==0);
    }
    ensure("destructed",exists==false);
  }

  /**
   * Checks assignment.
   */
  template<>
  template<>
  void object::test<5>()
  {
    {
      std::auto_ptr<existing> ap(new existing(exists));
      existing* p1 = ap.get();
      std::auto_ptr<existing> ap2;
      ap2 = ap;
      ensure("same pointer",p1==ap2.get());
      ensure("lost ownership",ap.get()==0);
    }
    ensure("destructed",exists==false);
  }

  /**
   * Checks copy constructor.
   */
  template<>
  template<>
  void object::test<6>()
  {
    {
      std::auto_ptr<existing> ap(new existing(exists));
      existing* p1 = ap.get();
      std::auto_ptr<existing> ap2(ap);
      ensure("same pointer",p1==ap2.get());
      ensure("lost ownership",ap.get()==0);
    }
    ensure("destructed",exists==false);
  }
}

[Pellaeon]

In C++ sind Strukturen auch nur Klassen mit dem einzigen Unterschied, dass von Start weg erst einmal alle Elemente public sind(bei class sind ja erstmal alle private)

Zur zweiten Frage: schau mal genau, da wird eine zweite Strutkur in der Struktur definiert(struct existing). Man darf ha schachteln. Und demzufolge ist die Zeile einfach der Konstruktor der inneren Struktur, der dort definiert wird.

[Bernd_]

Ich versteh im unteren Code Abschnitt nicht ganz, was damit passiert shared_ptr<keepee> def;

Dies: shared_ptr def;
Wuerde ein Object vom Tzp shared_ptr anlegen, aber was kann man denn mit den <> Klammern da noch angeben? Die werden doch bei Templates verwendet?

Danke!

#include <tut.h> 
#include <shared_ptr.h>
namespace tut 
{ 
	struct shared_ptr_data 
	{ 
		struct keepee{ int data; }; 
	};

	typedef test_group<shared_ptr_data> testgroup; 
	typedef	testgroup::object testobject; 
	testgroup shared_ptr_testgroup("shared_ptr");

	// checks default constructor. 
	template<> template<> 
	void testobject::test<1>() 
	{ 
		shared_ptr<keepee> def;
		ensure("null",def.get()== 0); 
	} 
};

[Pellaeon]

Bernd_ schrieb:

Wuerde ein Object vom Tzp shared_ptr anlegen, aber was kann man denn mit den <> Klammern da noch angeben? Die werden doch bei Templates verwendet?

Richtig, das ist ein Template. Per #include <shared_ptr.h> wird hier anscheinend ein Template für einen Smartpointer reingezogen und an dieser Stelle (shared_ptr<keepee> def;) wird das Template mit dem Typ keepee benutzt.