C++ Entrée De La Surcharge D'Opérateur

Je suis en train de la surcharge de l'opérateur d'entrée sur un UserLogin classe que j'ai créé. Pas d'erreurs de compilation sont jetés, cependant les valeurs ne sont pas définies.

Tout fonctionne, mais le contenu de l'ul reste:
string id est sally
Le temps de connexion est 00:00
Temps de déconnexion est 00:00

Point D'Entrée

#include <iostream>
#include "UserLogin.h"

using namespace std;

int main() {
    UserLogin ul;

    cout << ul << endl; //xxx 00:00 00:00
    cin >> ul; //sally 23:56 00:02
    cout << ul << endl; //Should show sally 23:56 00:02
                        //Instead, it shows xxx 00:00 00:00 again

    cout << endl;
    system("PAUSE");
}

UserLogin.h

#include <iostream>
#include <string>
#include "Time.h"

using namespace std;

class UserLogin
{
    //Operator Overloaders
    friend ostream &operator <<(ostream &output, const UserLogin user);
    friend istream &operator >>(istream &input, const UserLogin &user);

    private:
        //Private Data Members
        Time login, logout;
        string id;

    public:
        //Public Method Prototypes
        UserLogin() : id("xxx") {};
        UserLogin( string id, Time login, Time logout ) : id(id), login(login), logout(logout) {};
};

UserLogin.cpp

#include "UserLogin.h"

ostream &operator <<( ostream &output, const UserLogin user )
{
    output << setfill(' ');
    output << setw(15) << left << user.id << user.login << " " << user.logout;

    return output;
}

istream &operator >>( istream &input, const UserLogin &user )
{
    input >> ( string ) user.id;
    input >> ( Time ) user.login;
    input >> ( Time ) user.logout;

    return input;
}
Êtes-vous sûr que c'est le code? Le friend istream l'opérateur prend la const référence, mais la lecture de l'objet ne pouvait pas être un const opération.
Oui, mais la jette utilisé dans l'entrée de l'opérateur dire que l'OP n'est pas la lecture de l'objet, mais dans temporaires (probablement sur VC, de sorte que les temporaires peuvent se lier à des >> non-const références).

OriginalL'auteur user1960364 | 2013-01-16

  1. 10

    Votre définition de operator>> est faux. Vous devez passer la user argument par des non-const de référence, et de se débarrasser des moulages:

    istream &operator >>( istream &input, UserLogin &user )
{
    input >> user.id;
    input >> user.login;
    input >> user.logout;

    return input;
}

    Les moulages sont à l'origine de vous lire dans un temporaire, qui est ensuite jetés immédiatement.

    Intéressant, parce que j'ai fait la même chose dans ma classe et ça a marché parfaitement. Toutefois, les modifications que vous avez mentionné avoir résolu le problème...
    Comment accepter la réponse, alors? (C'est comment ça fonctionne, en général).

    OriginalL'auteur Angew

  2. 0
    input >> (type) var;

    est mal, ne le faites pas. Faire simple

    input >> var;
    J'ai ajouté le jette parce qu'il était de lancer une erreur. La jette résolu l'erreur mais apparemment pas le problème sous-jacent de l'Utilisateur en cours de const.
    L'ajout de jette est une façon de lutter contre les erreurs que vous ne comprenez pas, mais la découpe de vos doigts à l'écart est plus efficace et moins de douleur dans le long terme. des précisions je ne suis pas de préconiser une ou l'autre action.

    OriginalL'auteur n.m.

  3. -2
    #ifndef STRING_H
#define STRING_H

#include <iostream>
using namespace std;

class String{
    friend ostream &operator<<(ostream&,const String & );


    friend istream &operator>>(istream&,String & );

public:
    String(const char[] = "0");
    void set(const char[]);
    const char * get() const;
    int length();

    /*void bubbleSort(char,int);
    int binSearch(char,char,int);

    bool operator==(const String&);
    const String &operator=(const String &);
    int &operator+(String );*/

private:
        const char *myPtr;
    int length1;

};
#endif

    OriginalL'auteur frank