mein programm läuft soweit doch mein lehrer sagt, dass ich die Objektorientierung nicht richtig umsetze, allerdings weiß ich nicht was ich anders machen sollt.

hier mein code:

#include <iostream>
using namespace std;

//Klasse
class PRIMZAHL
{
private:
int Zahl1;
int Zahl2;
public:
void vorherige(int, int);
void istPrim(int, int);
};

//Funktionsaufruf für Primzahlen absteigend
void PRIMZAHL::vorherige(int z1, int z2) //Outline-Funktion
{
cout << "-------------------------------------------------------------"<<endl;
cout <<"Die Primzahlen lauten absteigend: " <<endl;

PRIMZAHL p1;

p1.Zahl1 = z1;
p1.Zahl2 = z2;

int Divisor;
bool prim;
for (z2; z2>=z1; z2--)
{
prim = true;
// Pruefe, ob Primzahl wirklich eine Primzahl ist
for (Divisor = 2; prim && Divisor < z2;
Divisor++)
{
// Ist das restlos teilbar?
if (0==z2 % Divisor)
{
// Zahl ist teilbar, ist also keine Primzahl!
prim = false;
}
}
// Pruefung ist beendet.
// Wenn es eine Primzahl ist, ausgeben!
if (prim)
{
cout << z2 << ", " ;
}
}
cout << endl <<endl;
}

//Funktionsaufruf für Primzahlen aufsteigend
void PRIMZAHL::istPrim(int z1, int z2) //Outline-Funktion
{
cout << "-------------------------------------------------------------"<<endl;
cout <<"Die Primzahlen lauten aufeinander folgend: " <<endl;

PRIMZAHL p1;

p1.Zahl1 = z1;
p1.Zahl2 = z2;

int Divisor;
bool prim;
for (z1; z1<=z2; z1++)
{
prim = true;
// Pruefe, ob Primzahl wirklich eine Primzahl ist
for (Divisor = 2; prim && Divisor < z1;
Divisor++)
{
// Ist das restlos teilbar?
if (0==z1 % Divisor)
{
// Zahl ist teilbar, ist also keine Primzahl!
prim = false;
}
}
// Pruefung ist beendet.
// Wenn es eine Primzahl ist, ausgeben!
if (prim)
{
cout << z1 << ", " ;
}
}
cout << endl <<endl;
}

//Main-Funktion
void main()
{

int Zahl1;
int Zahl2;

//Instanzzierung
PRIMZAHL p1;

cout <<"Herzlich Willkommen zur Primzahl-Achterbahn!" << endl << endl;
cout <<"Bitte tragen sie den Bereich ein: " << endl;
cout <<"von: ";
cin >> Zahl1;
cout <<"bis: ";
cin >> Zahl2;
cout << endl <<endl;
p1.vorherige(Zahl1, Zahl2);
p1.istPrim(Zahl1, Zahl2);
}

[code]
//Funktionsaufruf für Primzahlen absteigend
void vorherige(int z1, int z2) //Outline-Funktion
{
...
}

void istPrim(int z1, int z2) //Outline-Funktion
{
...
}

//Main-Funktion
void main()
{
int Zahl1;
int Zahl2;

cout <<"Herzlich Willkommen zur Primzahl-Achterbahn!" << endl << endl;
cout <<"Bitte tragen sie den Bereich ein: " << endl;
cout <<"von: ";
cin >> Zahl1;
cout <<"bis: ";
cin >> Zahl2;
cout << endl <<endl;
vorherige(Zahl1, Zahl2);
istPrim(Zahl1, Zahl2);
}
[code]

Das ist alles was Dein Code macht, die Klasse benutzt Du eigendlich nur um die beiden Funktionen aufzurufen. Wie Du siehst kann man die Klasse auch einfach ganz weglassen und dein Programm läuft genauso wie vorher. Du hast zwar innerhalb deiner Klasse Variablen für die Werte Deklariert (richtiger Ansatz), benutzt dann aber die Variablen aus dem main.

Damit ist das was Du machst nichts anderes als ein normaler prozeduraler Ablauf.

wäre nett wenn jemand den code berichtigen würde.

danke

Du solltest vielleicht den Code zur Prüfung einer Zahl auf Primzahl in eine Funktion fassen.
Dann brauchst Du die Schleife, die alle Primzahlen in einem Bereich sucht nur einmal laufen lassen, merkst Dir die Zahlen (z.B. in einem std::vector<int>) und gibst sie in umgekehrter Reihenfolge wieder aus.

Aber das ist alles prozedural und das ist auch ok so.

Es gibt natürlich auch die Möglichkeit einen Primzahl-Iterator zu bauen; das wäre dann zumindest eine Klasse, die vielleicht Sinn macht, aber als Anfänger-Beispiel für Objektorientierung taugt das nicht.

Wie stellt sich denn Dein Lehrer das vor?

Gruß
Werner

Mfg Ominion

wenn man primzahlen mit bestimmeten eigenschaften sucht, die nicht gerade wie sand am strand rumliegen, ist es nett, einen PrimzahlGenerator zu schreiben. innendrin liegt normalerweise ein sieb. aber egal, total objektorientert können wir auch innendrin nur einen int haben oder einen int und dessen rest bei dicision durch 30 oder wasauchimmer gefallen mag. nehmen wir mal nur einen int.

class Primzahl
{ 
private: 
int zahl;
public: 
Primzahl(int x){
   zahl=x;
}
Primzahl vorherige(){
   do{
      --zahl;
   }while(istPrimzahl(zahl));
   return Primzahl(zahl);
}
Primzahl naechste();
};

so ergibt es fast schon sinn. nur was machen wir, wenn der benutzer in der main() sowas wie Primzahl p(100) verlangt? 100 ist keine Primzahl!

vielleicht so:

Primzahl(int x,bool suchAufwärtsWennNichtPrim=true){
   zahl=x;
   while(!istPrimzahl(zahl)){
      if(suchAufwärtsWennNichtPrim)
         ++zahl;
      else
         --zahl;
   }
}

jo, dieser schnittstelle kann ich bescheinigen, daß sie verdammt praktisch ist und monatelang stabil bleibt, selbst bei einem spielkind wie mir.

int main(){
   if(aufwärts){
      cin<<start<<ende;
      for(Primzahl p(start);p<=ende;p=p.naechste())
         cout<<p.zahl<<' ';
   }
   else
      cin<<start<<ende;
      for(Primzahl p(start,false);p>=ende;p=p.vorige())
         cout<<p.zahl<<' ';
   }
}

alles ungetestet und nur so als befruchtung gedacht.

nur was machen wir, wenn der benutzer in der main() sowas wie Primzahl p(100) verlangt? 100 ist keine Primzahl!

vielleicht so:

Primzahl(int x,bool suchAufwärtsWennNichtPrim=true){
   zahl=x;
   while(!istPrimzahl(zahl)){
      if(suchAufwärtsWennNichtPrim)
         ++zahl;
      else
         --zahl;
   }
}

Ich würd ne exception schmeißen, ist ja schon fast wie durch 0 teilen.