erstes prog mit Klassen,und direkt Fehler...

deejay ray

wieso bekomme ich denn jetzt hier nur Fehlermeldungen ? habs genauso ausm Buch abgetippt;

// Implementierung der Zeilen
// Zeile1.cpp

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "Zeile1.hpp"

Zeile::Zeile (char * text);
{
    Laenge = strlen (text) +1 // Laenge merken
    Inhalt = new char[Laenge];//Speicher holen
    if (Inhalt == NULL)
        exit(1);
    strcpy (Inhalt,text);        // Inhalt kopieren
}

Zeile::~~Zeile()
{
    delete Inhalt;
}

void Zeile::print()
{
    printf (Inhalt);

// Klasse mit dynamischer Speicherverwaltung
// Zeile1.hpp

class Zeile
{
    int Laenge;
    char * Inhalt;

    public:
    Zeile (char * ctext);
    ~Zeile();
    void print();
};

// Hauptprogramm für zeile
// z1main.cpp

#include <stdio.h>
#include "Zeile1.hpp"

int main()

{
    Zeile z1("\nGuten Tag!\n";
    z1.print(); // Inhalt ausgeben
    return 0;
}

Erhard Henkes

Klasse MyString, die die "Großen Drei" (Copy-Konstruktor, Zuweisungsoperator, Destruktor) in Aktion zeigt:

#include <iostream>
#include <iomanip>
#include <conio.h>
#include <cstring>

class MyString
{
public:
  MyString(char* pText=NULL);
  MyString(const MyString& str);               // Copy-Konstruktor
  MyString& operator=(const MyString& str);    // Zuweisungsoperator
  ~MyString();

  void output();
  void showaddress();

private:
  char* pText_;
};

MyString::MyString(char* pText)
{
  if (pText)
  {
    pText_ = new char[ strlen(pText+1) ];
    strcpy(pText_, pText);
  }
  else
  {
    pText_ = new char[1];
    *pText_='\0';
  }
}

MyString::MyString(const MyString& str)            // Copy-Konstruktor
{
  pText_ = new char[ strlen(str.pText_+1) ];
  strcpy(pText_, str.pText_);
}

MyString& MyString::operator=(const MyString& str) // Zuweisungsoperator
{
  pText_ = new char[ strlen(str.pText_+1) ];
  strcpy(pText_, str.pText_);
  return *this; // Unterschied zum Copy-Konstruktor
}

inline MyString::~MyString()
{
  delete[] pText_;
}

void MyString::output()
{
  std::cout << pText_ << std::endl;
}

void MyString::showaddress()
{
  std::cout << std::endl << std::hex << int(pText_) << ": ";
}

int main()
{
  MyString str1("hello, world");

  MyString str2(str1); // Copy-Konstruktor

  MyString str3;
  str3 = str2;         // Zuweisungsoperator

  MyString str4("");

  MyString str5;

  str1.showaddress();   str1.output();
  str2.showaddress();   str2.output();
  str3.showaddress();   str3.output();
  str4.showaddress();   str4.output();
  str5.showaddress();   str5.output();

  getch();
}

fubar

#include <stdio.h> 
#include "Zeile1.hpp" 

int main() 

{ 
    Zeile z1("\nGuten Tag!\n"); //schließende Klammer fehlte...
    z1.print();
    return 0; 
}

Liegt es vielleicht daran?

Erhard Henkes

Zum Experimentieren (incl. Vererbung):

#include <string>
#include <iostream>

void wait() // die C++-Alternative von getch() ;)
{
    std::cin.clear();

    std::streambuf* pbuf = std::cin.rdbuf();
    std::streamsize size = pbuf->in_avail();
    std::cin.ignore(size);

    std::cin.get();
}

class Person
{
private:
	std::string Vorname;
	std::string Name;
	unsigned int Alter;
public:
	~Person();
	Person();
	void setVorname(const std::string& value);
	const std::string& getVorname() const;
	void setName(const std::string& value);
	const std::string& getName() const;
	void setAlter(const unsigned int & value);
	const unsigned int & getAlter() const;
};

const unsigned int & Person::getAlter() const
{
  return Alter;
}

void Person::setAlter(const unsigned int & value)
{
  Alter = value;
}

const std::string& Person::getName() const
{
  return Name;
}

void Person::setName(const std::string& value)
{
  Name = value;
}

const std::string& Person::getVorname() const
{
  return Vorname;
}

void Person::setVorname(const std::string& value)
{
  Vorname = value;
}

Person::Person(){}

Person::~Person(){}

class Dozent : public Person
{
private:
	unsigned int Kurse_noch_geplant;
	unsigned int Kurse_gehalten;
public:
	void setKurse_noch_geplant(const unsigned int & value);
	const unsigned int& getKurse_noch_geplant() const;
	void setKurse_gehalten(const unsigned int & value);
	const unsigned int& getKurse_gehalten() const;
	~Dozent();
	Dozent();
};

Dozent::Dozent() : Kurse_gehalten(0), Kurse_noch_geplant(0) {}

Dozent::~Dozent(){}

const unsigned int & Dozent::getKurse_gehalten() const
{
  return Kurse_gehalten;
}

void Dozent::setKurse_gehalten(const unsigned int & value)
{
  Kurse_gehalten = value;
}

const unsigned int & Dozent::getKurse_noch_geplant() const
{
  return Kurse_noch_geplant;
}

void Dozent::setKurse_noch_geplant(const unsigned int & value)
{
  Kurse_noch_geplant = value;
}

int main()
{
  Dozent obj;
  obj.setName("Allwissend");
  obj.setVorname("Hugo");  
  obj.setAlter(85);
  obj.setKurse_gehalten(13);
  obj.setKurse_noch_geplant(2);
  std::cout << obj.getVorname() << " " << obj.getName() << " " << obj.getAlter() << " Jahre alt" << std::endl;
  std::cout << obj.getKurse_gehalten() << " Kurse schon gehalten." << std::endl;  
  std::cout << obj.getKurse_noch_geplant() << " Kurse noch geplant." << std::endl;  

  wait();
}