Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Datenbankabfrage funzt nicht richtig....

Werbeanzeige

grek40

Alter Hase

Beiträge: 1 491

Wohnort: Dresden

  • Private Nachricht senden

11

17.05.2007, 19:22

Sorry wegen dem L"..." - ich code immer UNICODE oder universal (also _T("")) das gehört da natürlich nicht hin^^

//
Ich nehme an, dass du VC++ hast - gib doch einfach mal den Code in eine entsprechende Datei ein und drücke F1 - dann solltest du auch erfahren, wie die von mir geschriebenen Sachen arbeiten.

Deviloper

Community-Fossil

Beiträge: 2 872

  • Private Nachricht senden

12

17.05.2007, 20:08

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

#include <iostream>
#include <string>
#include <fstream>

void login(const std::string&, const std::string&);
void register_user(const std::string&, const std::string&);

int main()
{
    std::cout << "Calculator V0.1 Beta" << std::endl;
    unsigned short sel = 0;
    while (sel != 3)
    {
        std::cout << "(1) Login" << std::endl;
        std::cout << "(2) Registrieren" << std::endl;
        std::cout << "(3) Beenden" << std::endl;
        
        do {
            std::cout << "Eingabe: " << std::flush;
        } while (!(std::cin >> sel) || sel > 3 || sel < 1);
    
        switch (sel)
        {
        case 1:
            {
                std::cout << ".Login" << std::endl;
                std::cout << "- Benutzername: " << std::flush;
                std::string user_name;
                std::getline(std::cin, user_name);
                std::cout << "- Passwort: " << std::flush;
                std::string password;
                std::getline(std::cin, password);
                try {
                    login(user_name, password);
                } 
                catch (std::exception e)
                {
                    std::cout << e.what() << std::endl;
                }
            } break;
        case 2:
            {
                std::cout << ".Registrieren" << std::endl;
                std::cout << "- Benutzername: " << std::flush;
                std::string user_name;
                std::getline(std::cin, user_name);
                std::string password;
                std::string password_rev;
                do {                
                    std::cout << "- Passwort: " << std::flush;
                
                    std::getline(std::cin, password);
                    std::cout << "- Passwort wiederholen: " << std::flush;
                    std::getline(std::cin, password_rev);
                } while (password != password_rev);

                register_user(password, user_name);
            } break;
        default: break;
        }
    }
}

void login(const std::string& user_name, const std::string& password)
{
    std::ifstream file_stream("user.txt", std::ios::in);
    if (!file_stream)
        throw "Could not open file!";

    std::string read_name;
    std::string read_pw;
    while ((std::getline(file_stream, read_name)) && (std::getline(file_stream, read_pw)))
        if (read_name == user_name)
            if (read_pw != password)
                throw "Invalid password!";
            else
                return;

    throw "Could not find user!";   
} 

void register_user(const std::string& user_name, const std::string& password)
{
    std::ofstream file_stream("user.txt", std::ios::out);
    if (!file_stream)
        return;
    
    file_stream << user_name << std::endl;
    file_stream << password << std::endl;
}
oder so ähnlich sollte gehen ... hab es nicht getestet ... aber nja müsste trotzdem io gehen ;)
Devil Entertainment :: Your education is our inspiration
Der Spieleprogrammierer :: Community Magazin
Merlin - A Legend awakes :: You are a dedicated C++ (DirectX) programmer and you have ability to work in a team? Contact us!
Siedler II.5 RttR :: The old settlers-style is comming back!

Also known as (D)Evil

DEATH

Treue Seele

  • »DEATH« ist der Autor dieses Themas

Beiträge: 109

  • Private Nachricht senden

13

18.05.2007, 10:02

gut danke, hab aber noch weitere fragen:

1. @ Theprogrammer

Danke für deine Antwort die mir so gut wie nix gebracht hat... was ist STL ??? und ich weiss was UNICODE heisst aber woher das 'L' kommt, hab ich kein plan.. aber danke dem lieben David_pb und dem grek40, weiss ich es jetzt.

2. @ David_pb
2.1. Vielen dank für die kurzen und aussagekräftigen antworten.

2.2.
Ich schreibe alle meine Objekte im namespace std; und tue niemals ein std:: vor cin und cout.... und alles funzt bei mir ohne probs :P

3. @ Deviloper
ha, du hast einen Fehler drinn :P . Wenn man sich registriert, muss man insgesammt 4mal das passwort eingeben :P

Quellcode

 
1
2
3
4

Passwort:
Passwort wiederholen:
Passwort:
Passwort wiederholen:


aber trotzdem danke für den Code xD jetzt hab ich noch mehr fragen dazu^^

1. unsigned short sel = 0; was bewirkt diese zeile?
2. was heisst das:

C-/C++-Quelltext

 
1
2
3
4
5
6
7

try { 
                    login(user_name, password); 
                } 
                catch (std::exception e) 
                { 
                    std::cout << e.what() << std::endl; 
                }

insbesondere: was heisst exception.e und e.what()
und die schleife 'try' und 'catch' hab ich bisher auch noch nie gesehen...

3. was heisst das default: break; anstatt von return 0; ?
4. was heist 'throw' ( throw "Could not open file!": und throw "Could not find user!";

so das wars mal fürs erste :D

jetzt die Antworten bitte! Aber nicht rummeckern.... bin noch ein NOOB in C++ :(

David_pb

Community-Fossil

Beiträge: 3 886

Beruf: 3D Graphics Programmer

  • Private Nachricht senden

14

18.05.2007, 10:37

Hi!

1. Hier wird eine Variable vom Typ unsigned short (Integraler Typ ohne Vorzeichen) angelegt und mit 0 Initialisiert.
2. Hierfür findest du Informationen unter dem Begriff "Exception handling". Wenn eine Exception in einem try-Block auftritt kann diese per "catch" gefangen und entsprechend verarbeitet werden. Hierbei kommt es auf den Typ der Ausnahme an, der Typ in diesem Beispiel ist std::exception, kann aber auch jeder andere Typ sein. Wenn du alle Ausnahmen abfangen willst gibst du bei catch als Parameter "..." ein. Ein Beispiel:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11

try
{
  call( irgendwas ); // wirft eine exception vom typ int

}
catch ( int i ) // fängt alle ausnahmen vom typ int

{
  // behandeln

}
catch ( ... ) // fängt alle nicht gefangenen ausnahmen

{
}


Die Klasse std::exception hat eine Methode mit dem Namen what(). Diese Methode liefert dir die Beschreibung der aufgetretenen Ausnahme zurück, als const char*.

Anmerkung:
Sinniger wäre es Exceptions per Referenz zu fangen, nicht als Kopie:

C-/C++-Quelltext

 
1
2
3
4

try
{ ... }
catch ( std::exception& e )
{ ... }


3. default markiert in einer Switch-Case Anweisung den Zweig der verwendet wird wenn keine der anderen Fälle eintrifft. Allerdings ist das in dem unten genannten Beispiel total unsinnig.

4. throw wirft eine Ausnahme. In dem Fall eine Ausnahme vom Typ const char* (C-String). Diese Ausnahme kann dann per try-catch Konstrukt gefangen und behandelt werden. Was Deviloper nicht berücksichtigt zu haben scheint ist das die Exception niemals behandelt wird, in seinem Code! ;-)

Noch kurz was zum Thema Exceptions:

Man kann bei einer Funktion festlegen welcher Typ von Exceptions geworfen werden kann. Und zwar per throw( typ ) hinter dem Funktionskopf:

Beispiel: Funktion foobar wirft nur (evtl) eine Exception vom Typ int.

C-/C++-Quelltext

 
1
2

float foobar( const char* xyz ) throw ( int )
{}


Wenn keine Angabe da ist können alle Exceptions geworfen werden. Was die Behandlung erschwert. Wen keine Exception geworfen wird kann das per throw() gekennzeichnet werden.

Beispiel: Funktion foobar wirft garantiert niemals eine Exception

C-/C++-Quelltext

 
1
2

float foobar(const char* xyz ) throw()
{}


grüße
@D13_Dreinig

Deviloper

Community-Fossil

Beiträge: 2 872

  • Private Nachricht senden

15

18.05.2007, 11:08

hmm hab doch gesagt ist nicht getestet ... hatte net die Zeit es ordentlich zu machen sry ... nja

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

#include <iostream>
#include <string>
#include <fstream>

void login(const std::string&, const std::string&);
void register_user(const std::string&, const std::string&);

int main()
{
    std::cout << "Calculator V0.1 Beta" << std::endl;
    unsigned short sel = 0;
    while (sel != 3)
    {
        std::cout << "(1) Login" << std::endl;
        std::cout << "(2) Registrieren" << std::endl;
        std::cout << "(3) Beenden" << std::endl;
       
        do {
            std::cout << "Eingabe: " << std::flush;
        } while (!(std::cin >> sel) || sel > 3 || sel < 1);
        
        std::cin.clear();
        std::cin.ignore(std::cin.rdbuf()->in_avail());
        
        switch (sel)
        {
        case 1:
            {
                std::cout << ".Login" << std::endl;
                std::cout << "- Benutzername: " << std::flush;
                std::string user_name;
                std::getline(std::cin, user_name);
                std::cout << "- Passwort: " << std::flush;
                std::string password;
                std::getline(std::cin, password);
                try {
                    login(user_name, password);
                }
                catch (std::exception& e)
                {
                    std::cout << e.what() << std::endl;
                }
            } break;
        case 2:
            {
                std::cout << ".Registrieren" << std::endl;
                std::cout << "- Benutzername: " << std::flush;
                std::string user_name;
                std::getline(std::cin, user_name);
                std::string password;
                std::string password_rev;
                do {               
                    std::cout << "- Passwort: " << std::flush;
               
                    std::getline(std::cin, password);
                    std::cout << "- Passwort wiederholen: " << std::flush;
                    std::getline(std::cin, password_rev);
                } while (password != password_rev);

                register_user(user_name, password);
            } break;
        }
    }
}

void login(const std::string& user_name, const std::string& password)
{
    std::ifstream file_stream("user.txt", std::ios::in);
    if (!file_stream)
        throw std::exception("Could not open file!");

    std::string read_name;
    std::string read_pw;
    while ((std::getline(file_stream, read_name)) && (std::getline(file_stream, read_pw)))
        if (read_name == user_name)
            if (read_pw != password)
                throw std::exception("Invalid password!");
            else
                return;

    throw std::exception("Could not find user!");   
}

void register_user(const std::string& user_name, const std::string& password)
{
    std::ofstream file_stream("user.txt", std::ios::out);
    if (!file_stream)
        return;
   
    file_stream << user_name << std::endl;
    file_stream << password << std::endl;
}
so geht's ... ist aber nicht die beste Methode das zu machen ...
Devil Entertainment :: Your education is our inspiration
Der Spieleprogrammierer :: Community Magazin
Merlin - A Legend awakes :: You are a dedicated C++ (DirectX) programmer and you have ability to work in a team? Contact us!
Siedler II.5 RttR :: The old settlers-style is comming back!

Also known as (D)Evil

David_pb

Community-Fossil

Beiträge: 3 886

Beruf: 3D Graphics Programmer

  • Private Nachricht senden

16

18.05.2007, 11:10

War ja kein Vorwurf nur ne Anmerkung! ;) Achja, wo wir schon dabei sind:

C-/C++-Quelltext

 
1
2

std::cin.clear(); 
std::cin.ignore(std::cin.rdbuf()->in_avail());


Sowas sollte tunlichst vermieden werden. Dass das funktioniert ist egtl hoch Compilerabhängig und sollte lieber anders gelöst werden. Zum Beispiel sicherstellen das keine Restbestände im Puffer bleiben oder die auf korrekte Art auslesen, in einem String z.B.
@D13_Dreinig

grek40

Alter Hase

Beiträge: 1 491

Wohnort: Dresden

  • Private Nachricht senden

17

18.05.2007, 11:14

Zitat von »"David_pb"«


Anmerkung:
Sinniger wäre es Exceptions per Referenz zu fangen, nicht als Kopie:

C-/C++-Quelltext

 
1
2
3
4

try
{ ... }
catch ( std::exception& e )
{ ... }



Wenn schon, dann würde ich const nehmen:

C-/C++-Quelltext

 
1

catch ( const std::exception& e )


Oder hab ich jetzt schon wieder irgendwelche Sonderregelungen für exceptions vergessen?

David_pb

Community-Fossil

Beiträge: 3 886

Beruf: 3D Graphics Programmer

  • Private Nachricht senden

18

18.05.2007, 11:21

Könntest du, wobei das ziemlich egal ist das es sich mit hoher Wahrscheinlichkeit sowiso um ein temporäres Objekt handelt. Bzw oftmal ist es sogar erwünscht das Exceptions in der Catch Klausl modifiziert werden, wenn die Ausnahme weitergeleitet wird zum Beispiel.

Das einzige Argument wär die Optimierung die der Compiler evtl durchführen könnte.

P.S.: Im Übrigen sind das keine Sonderregelungen sondern Vorbeugung gegen Objectslicing und unnötige Kopiererei.
@D13_Dreinig

DEATH

Treue Seele

  • »DEATH« ist der Autor dieses Themas

Beiträge: 109

  • Private Nachricht senden

19

18.05.2007, 11:57

phuuu...
anscheinend sind Exceptions und co. schwierige themen....

:P @ David_pb:
mit den exceptions hab ich's in etwa so kapiert(rofl):
wenn eine Ausnahme in ner try schleife 'rumrennt' kann sie mit catch gefangen werden... klingt verdammt komisch xD

Was für Ausnahmen sind mit Exception gemeint??


Ich such mal im i-net wo des für Anfänger ausführlicher erklärt wird....

EDIT:
Ach du scheis(s)e ist das kompliziert x_X (habe etwas über die oben genannten 'exceptions' in wikipedia gefunden...)

Wäre hier jemand bereit mir die ganzen exception zu erklären??
(am besten anhand von sau einfachen beispielen....)
ICQ: 277-775-586

David_pb

Community-Fossil

Beiträge: 3 886

Beruf: 3D Graphics Programmer

  • Private Nachricht senden

20

18.05.2007, 12:35

Jo, Exception handling kein besonderst leichtes Thema u.A. da es noch relativ jung ist und noch keine Optimalen Lösungsvorschläge existieren. Die Grundlagen sind aber relativ leicht zu lernen (wie immer!;)).

Hier mal ne Kurzfassung:

Ausnahmen werfe
Exceptions (Ausnahmen) können per throw geworfen werden:

C-/C++-Quelltext

 
1
2
3
4

// code ...

throw 10; // Wirft eine Ausnahme vom Typ int

throw std::string( "Hallo Welt" ); // Wirft eine Ausnahme von Typ std::string

throw std::logic_error( "Foobar" ); // Wirft eine Ausnahme vom Typ std::logic_error


Wie man sieht kann ein Ausnahmeobjekte quasi jeden Typ haben. Es ist allerdings wichtig den Typ zu kennen um die Ausnahme auch wieder einzufangen.

Ausnahmen fangen
Ausnahmen werden gefangen indem die Funktion welche die Ausnahme erzeugt in einen try-block gepackt wird. Alle Ausnahmen die in diesem Try-Block auftreten können behandelt werden und zwar in dem man sie per catch() fängt.

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8

try
{
   throw std::logic_error( "fehler" );
}
catch ( const std::logic_error& e )
{
   std::cout << e.what() << std::endl;
}


Wenn kein entsprechendes catch() vorhanden ist dann wird die Ausnahme nicht behandelt und verhält sich wie ohne den ganzen try-catch Mist.
Es ist übrigens möglich mehrere catch() Blöcke zu erstellen um verschiedene Typen von Ausnahmen abzufangen. Die Blöcke werden von oben nach unten abgearbeitet, es ist also darauf zu achten das spezialisierte Klassen (abgeleitet von xyz) vor ihren Basisklassen behandelt werden müssen.

Einer für alle
Sollen einfach alle Ausnahmetypen in einem catch-Block landen geht das per "...".

C-/C++-Quelltext

 
1
2
3
4
5
6
7

try
{
   throw xyz();
}
catch ( ... )
{
}


Werfen von Exceptions 2
Grundlegend sollte man Ausnahmen immer "by value" werfen. Nicht als Zeiger oder Referenz.

Fangen von Exceptions 2
Grundlegend sollten Ausnahmen immer "by reference" gefangen werden. Weil: Slicingprobleme, unnötiges kopieren, möglichkeit Ausnahme zu ändern bei weiterleiten selbiger.

Ausnahmen weiterleiten
Wenn eine Ausnahme nicht in einem try-catch Konstrukt behandelt werden soll kann diese einfach weitergeleitet werden.

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8

try
{
  throw std::logic_error( "fooabar" );
}
catch ( ... ) // <- fängt alle exceptions

{
  throw; // leitet die exception weiter

}


Die weiterleitung ermöglicht dann das behandeln der Exception in einem anderen Teil des Programms.

Markieren von Funktionen als potentielle Ausnahmewerfer
Einer Funktion kann zugeteilt werden welche Ausnahmen sie theoretisch werfen kann.

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11

void foo() throw( bar_exception ) // foo wirft evtl eine Exception vom typ bar_exception, aber sonst keine andere

{
}

void foo() // foo kann jeden Ausnahmetyp werfen

{
}

void foo() throw() // foo wirft definitiv niemals eine Ausnahme

{
}


Was das behandeln der Ausnahmen deutlich erleichtert.

So, ich hoff ich hab nichts vergessen bei der Kurzübersicht. Viel Spaß noch mit den Ausnahmen! :P
@D13_Dreinig

Werbeanzeige