#include <cstdlib>
#include <iostream>

using namespace std;

int random() 
{ 
    int random_integer; 
    int lowest=1000, highest=9999; 
    int range=(highest-lowest)+1; 
    random_integer = lowest+int(range*rand()/(RAND_MAX + 1.0)); 
    return (random_integer); 
}

int quer(int zahl) {
    int quer=0;
    int rest=0;

    do {
        rest = zahl%10;
        zahl = zahl/10;
        quer=quer+rest;
    } while (zahl > 0);

    return quer;
}

int main()
{
    srand((unsigned)time(0));
    int a = random();
    int b = quer(a);
    cout << a << "\n";
    cout << b << "\n";

    do 
    {
    b = quer(b); 
    cout << b << "\n";
    } while ( b > 9);

    system("PAUSE");
    return EXIT_SUCCESS;
}

funktioniert auch tadellos.

nun möchte ich aber diese methoden in einer klasse zusammenfassen.

wie stell ich sowas am besten an. und wie löse die runterbrechung auf eine ziffer eleganter?

später sollen auch noch weitere methoden hinzukommen, aber fürs erste reichen diese zwei.

bin für jede hilfe dankbar, tim

ob es sinn macht eine "quersummen-klasse" zu machen sei da mal so hingestellt. eher vielleicht als methode einer klasse die für berechnungen vorhanden ist oder so. lies dir mal was zum thema sinn einer klasse etc. durch.

header-datei

// tool.h
#ifndef _PROGRAMM_
#define _PROGRAMM_

#include <iostream>

// oft sinnvoll
namespace util {
	// Klassenbezeichnung
	class CCalc {
		public:
			// Konstruktor
			CQuer();

			//Destruktor
			~CQuer();

			// Zufallsmethode für int
			int random()

			// Methode für Quersumme (int)
			int quer(int zahl);

			// setzt variable bspl
			void setBspl(int wert);

			// liefert variable bspl
			int getBspl();

		private:
			// hier kommt geschütztes zeugs rein
			// .. zugriff von außen nur über public
			// beispiel bspl kann nur über getter/setter methode verändert werden.
			int m_bspl;
	};
}

#endif // _PROGRAMM_

source-datei

// tool.cpp
#include "datei.h"

//konstruktor
util::CQuer::CQuer() {
	// hier was zum initialisieren etc.
}

//destruktor
util::CQuer::~CQuer() {
	// hier was vorm zerstören des objekts
}

//zufall
int util::CQuer::random() {
	// inhalt etc.
	int rand = ... usw
	return rand;
}

//quer
int util::CQuer::quer(int zahl) {
	int quersumme;
	//quersumme von wert bilden

	return quersumme;
}

//setzt variable m_bspl
void util::CQuer::setBspl(int wert) {
	m_bspl = wert;
}

//liefert variable m_bspl
int util::CQuer::getBspl() {
	return m_bspl;
}

"start" datei

// main.cpp
#include "tool.h"

int main() {
	CQuer q;

	cout << "quersumme aus 123: " << q.quer(123) << endl << "zufallszahl: " << q.random() << endl;

	// geht natürlich auch:
	// int quersumme = q.quer(123);
	// int zufall = q.random();

	delete q;

	return 0;
}

so, aber links raussuchen hab ich jetzt keine lust mehr.
viel spaß und bis dann

ps gewöhn dir EXIT_SUCCES mal schnell wieder ab und nimm einfach ne 0, es sei denn du hast deine eigenen "fehlercodes", aber davon geh ich mal nicht aus

#include <iostream>

Ist zwar im Header ok, aber ich würde es doch eher in die start-Datei verschieben, da es nur dort verwendet wird.

Bei

int random()

fehlt ein Semikolon am Ende

Dann liegen cout und endl im Namensraum std::, d.h. entweder musst du std:: davor setzen, oder an den Anfang der Datei wo du es benutzen willst using namespace std; schreiben. (Ersteres vorzuziehen, und bitte niemals ein using in headern)

Zu guter letzt versuchst du mit

delete q;

ein Objekt was *nicht* mit new erzeugt wurde zu löschen, was einen Compilerfehler geben müsste.

Merke: Nur mit new erzeugte Objekte müssen mit delete; gelöscht werden, gleiches gilt für new[] und delete[].

class CQuer
{
   CQuer();
   ~CQuer();
};

Sonst verwirrst du ihn noch mehr...

Und Klassenname und Konstruktor/Destruktor müssen übereinstimmen:

class CQuer
{
   CQuer();
   ~CQuer();
};

Sonst verwirrst du ihn noch mehr...

vollkommen richtig, das hätte mir noch auffalen müssen..
der rest den kenny anzumerken hat is mit den worten

ist natürlich nicht getestet, nur vom prinzip her, blablabla! sind auch ein paar unsauberheiten drinne, aber so fürn anfang reichts.

zu beantworten.. gut, das delete kann wirklich weg, aber hier in diesem textfeld kann man ja auch mal was übersehen und ich hatte vorher halt ne version mit new.

kenny, natürlich hast du recht.

math.hpp

#if !defined MATH_HPP__INCLUDED
#define MATH_HPP__INCLUDED

#if (_MSC_VER >= 1300)
#pragma once
#endif // (_MSC_VER >= 1300)

#include <cstdlib>
#include <ctime>

namespace math
{
    int random(int min = 0, int max = 1000)
    {
        return min + static_cast<int>(((max - min) + 1) * std::rand() / (RAND_MAX + 1.0));
    }
    void random_init() { std::srand(static_cast<unsigned>(std::time(0))); }
    unsigned int checksum(int integer)
    {
        unsigned int result(0);
        for (; integer > 0; integer /= 10)
            result += integer % 10;
        return result;
    }
};

#endif // MATH_HPP__INCLUDED

So wäre das evtl. sinnvoll. Einfach in einen Namensraum legen und die Funktion am besten möglichst wiederverwandbar machen und bsw. min und max bei random nicht statisch setzen ...

main.cpp

#include <iostream>
#include "math.hpp"

int main()
{
    math::random_init();
    int integer(math::random());
    std::cout << "- Integer: " << integer << "\n"
              << "* Checksum: " << math::checksum(integer) << std::endl;
    std::cin.get();
}

... so hat das vieel mehr style

dann fass ich ma kurz zusammen was ich damit überhaupt machen will:

ziel der ganzen übung ist es einen zahlencode zu generieren:

1234 5678 9012 3456

in dieser form etwa.

die quersumme der ersten 4 ziffern soll mir rückschlüsse über den anbieter geben.

die quersumme der addition der 3 quersummen der anderen ziffern soll mir den wert des codes liefern. beispiel:

quersumme1 = 1 --> Anbieter A

quersumme2 = 8
quersumme3 = 3
quersumme4 = 9

summe = 20 -> quersumme = 2 --> wert = 30 euro

die quersummen sollen vorgegeben sein, so dass solange ein code generiert wird bis er auf die quersummen passt.

also es soll ne methode in der klasse ausgeführt werden mit 2 quersummen als vorgabe

keygen(int quer1, int quer2)
    ...
    return (code);

dieser gefundene code soll dann in einer txt datei abgeleget werden.

später, wenn der benutzer den code einlösen will, muss der eingegebene code mit der txt abgegliechen werden. wenn der code gefunden wurde, wird der wert gutgeschrieben und zu gleich aus der txt gelöscht.

also, ich muss da noch nen paar methoden schreiben, und deswegen dacht ich is ne klasse da ganz angebracht? oder bin ich da auf'n falschen weg?

bin für jede hilfe dankbar, tim

int random()
{
    int random_integer;
    int lowest=1000, highest=9999;
    int range=(highest-lowest)+1;
    random_integer = lowest+int(range*rand()/(RAND_MAX + 1.0));
    return (random_integer);
}

int quer(int zahl) {
    int quer=0;
    int rest=0;

    while (zahl > 9)
    {

    do {
        rest = zahl%10;
        zahl = zahl/10;
        quer = quer+rest;
    } while (zahl > 0);

    zahl = quer;
    quer=0;
    rest=0;

    } ;

    return zahl;
}

int code (int check)
           {
           int code = 0;
           while ( quer(code) != check)
                 {
                 code = random();
                 };
                 return (code);
           }

int ziffer(int zahl, int stelle)
    {
    if (stelle == 1)
       {     
               zahl = zahl / 1000;
               return (zahl%10);
               }
    else if (stelle == 2)
         {
                    zahl = zahl / 100;
                    return (zahl%10);
                    }
    else if (stelle == 3)
         {
                    zahl = zahl / 10;
                    return (zahl%10);
                    }
    else if (stelle == 4)
         {
                    return (zahl%10);
                    }
    }

AnsiString keygen(int provider, int cash)
     {
                  int a = code(provider);
                  int swap = 0;

                  do{
                       swap = code(cash);
                      } while(ziffer(swap,1) == 0 || ziffer(swap,2) == 0 || ziffer(swap,3) == 0 || ziffer(swap,4) == 0);

                  int b = code(ziffer(swap,1));
                  int c = code(ziffer(swap,2));
                  int d = code(ziffer(swap,3));
                  int e = code(ziffer(swap,4));

                  AnsiString key;
                  key = IntToStr(a) + " " +
                        IntToStr(b) + " " +
                        IntToStr(c) + " " +
                        IntToStr(d) + " " +
                        IntToStr(e);

                  return (key);
     }

zur zeit ruf ich funktion per button auf

void __fastcall TForm1::Button1Click(TObject *Sender)
{
Edit1->Text = keygen(StrToInt(Edit2->Text),StrToInt(Edit3->Text));
}

Erhard Henkes schrieb:

Also was ist und bewirkt dieses Objekt? Beschreibe es an deinem konkreten Beispiel mit seinen Attributen und Methoden. Dann kann man über den Sinn einer Abstrahierung (Klasse) nachdenken.

was genau meinst du damit??? werd nich schlau daraus!

tim