Et project med et ur som object

Måske er det ikke det du mener, men du kan kalde de forskellige funktioner fra main således:

int main( )
{
   
    clock sample;
    sample.set_time(3, 24, true); // kl 3:24
    sample.advance(10); // læg 10minutter til
    int nMinute = sample.get_minute();
    osv...
       
    return EXIT_SUCCESS;
}

Lad constructoren,copy constructor og += bruge set_time, der virker på længere sigt bedre.
Selvom copy constructoren i lige dette tilfælde kunne bruge binær kopiering er det normalt bedre at gøre det samme i alle tilfælde.
Du kan centralisere konsistence check i en seperat function der kaldes af både set_time og +.

Mener du med 3. at en function skal have en functions parameter eller mener du at den skal returnere en bool?

I set_time checker du ikke for negative værdier.

bævl, du checker for negative værdier, jeg må være ved at blive præ-senil.

Tak jpk og Segmose for jeres svar. Jeg vil proeve at komme videre med mit projekt. Segmose, kan du evt. give et eksempel med copy constructoren - jeg er ikke sikker paa at jeg helt har forstaaet det.

Jeg vender hoejst sandsynligt tilbage med nogle spoergsmaal, haaber i har mod paa det.
Tak!

Det segmose siger er at du kan bruge set_time funktionen i din copy constructor og operator overload funktioner, som fx:

clock::clock(clock& copyFrom)
{
  set_time(copyFrom.get_hour(), copyFrom.get_minute(), copyFrom.is_morning());
}

Du kunne også lave den som:
clock::clock(clock& copyFrom)
{
  my_hour = copyFrom.get_hour();
  my_minute = copyFrom.get_minute();
  my_morning = copyFrom.is_morning();
}

Det er generelt et spørgsmål om personlig holdning og stil...

I princippet dette:

    // Default Constructor
    MyClass( void ) { Setup(); }

    // Copy Constructor
    MyClass( const MyClass &r ) { Setup(); Copy( r ); }

    // Destructor
    virtual ~MyClass( void ) { Reset(); }

Hvis du har flere forskellige (overloadede) constructors og complicerede initialiseringer skal man jo ikke skrive hele koden en gang til men
lave de specielle ting for den enkelte constructor og så kalde Setup()
med passende parameter.
skal man jo ikke skreve

Tak for forklaringen af copy constructoren.
Jeg har forsoegt at kalde mine funktioner, men er desvaerre meget i tvivl om hvordan jeg skal kalde alle. Som i kan se har jeg kaldt set_time(9, 48, true), get_hour(),get_minute() samt is_morning(), men efter the gik jeg i staa med advance (1500). Set_time ser ud til at virke efter planen, jeg skal bare have fundet ud af hvordan den viser A.M og P.M.
Kan i hjaelpe mig med brugen af mine funktioner? Hvad med copy constructoren, hvordan bliver den kaldt?
Jeg beklager at mine spoergsmaal er lidt begynderagtige, men jeg bliver forhaabentlig klogere hver gang ;-)
Jeg har pastet mit opdaterede project.

#include <cassert>
#include <iostream>        // Provides cout and cin
#include <cstdlib>          // Provides EXIT_SUCCESS
using namespace std;        // Allows all Standard Library items to be used
class clock
    {
    public:
        // CONSTRUCTOR
        clock( );
    //clock(clock& copyFrom);// copy constructor
        // MODIFICATION FUNCTIONS
        void set_time(int hour, int minute, bool morning);
        void advance(int minutes);
        // CONSTANT FUNCTIONS
        int get_hour( ) const;
        int get_minute( ) const;
        bool is_morning( ) const;
    private:
        int my_hour;
        int my_minute;
        int my_morning;
    };

int main( )
{
   
    clock sample;
    int nHour, nMinute;
    bool nMorning;
    sample.set_time(9, 48, true);
    nHour = sample.get_hour();
    nMinute = sample.get_minute();
    nMorning = sample.is_morning();
    cout << nHour << ":"<< nMinute << ":"<< nMorning;
    sample.advance(1500); // Add 1500 minutes
   
    return EXIT_SUCCESS;
}


clock::clock( )
    {
        my_hour = 12;
        my_minute = 0;
        my_morning = true;
    }

/*
clock::clock::clock(clock& copyFrom)
{
  set_time(copyFrom.get_hour(), copyFrom.get_minute(), copyFrom.is_morning());
}
*/
   
    void clock::set_time(int hour, int minute, bool morning)
    // Library facilities used: cassert
    {
        assert(1 <= hour);
        assert(hour <= 12);
        assert(0 <= minute);
        assert(minute <= 59);

    my_hour = hour;
    my_minute = minute;
    my_morning = morning;
    }


    void clock::advance(int minutes)
    {
    clock sample1;
    const int MINUTES_IN_DAY = 24*60;
    const int MINUTES_IN_HALF_DAY = 12*60;
    const int MINUTES_IN_HOUR = 60;
   
    if (minutes >= MINUTES_IN_HALF_DAY)
      {
        my_minute = sample1.get_hour() * MINUTES_IN_HOUR + sample1.get_minute();
        my_minute = my_minute - MINUTES_IN_DAY;
        my_hour = my_minute / MINUTES_IN_HOUR;
        my_minute = my_minute % MINUTES_IN_HOUR;
        }
    else
        {
        my_hour = my_minute / 60;
        my_minute = my_minute % 60;
        }
    }

 

    int clock::get_hour( ) const
    {
    return my_hour;
    }

    int clock::get_minute( ) const
    {
    return my_minute;
    }

    bool clock::is_morning( ) const
    {
    return my_morning;
    }

/*    bool operator <(const clock& c1, const clock& c2)
    {
    // Check whether one is morning and the other is not
    if (c1.is_morning( ) && !c2.is_morning( ))
        return true;
    else if (c2.is_morning( ) && !c1.is_morning( ))
        return false;

    // Check whether one is 12 o'clock and the other is not
    else if ((c1.get_hour( ) == 12) && (c2.get_hour( ) != 12))
        return true;
    else if ((c2.get_hour( ) == 12) && (c1.get_hour( ) != 12))
        return false;

    // Check whether the hours are different from each other
    else if (c1.get_hour( ) < c2.get_hour( ))
        return true;
    else if (c2.get_hour( ) < c1.get_hour( ))
        return false;

    // The hours are the same, so check the minutes
    else if (c1.get_minute( ) < c2.get_minute( ))
        return true;
    else
        return false;
    }
*/

Copy constructor bruges når du copierer fra et exemplar til et andet af
samme type(class).

clock
  a, b;

a = b;

Dette kan gå rigtig galt hvis du fx. har allocket plads i din klasse.

segmose >> mener du ikke:
clock a;
clock b = a; // her kaldes copy constructor

clock a, b;
a = b; // her kaldes assignment operator

I sidste eksempel er objektet jo konstrureret i første linie...

hmm Stoustrup 10.2.5: memberwise copy

så ja, samme problem forskellig steder det skal løses.
assignment har yderligere problemer med at data i objectet
allerede er initialiseret/constructed.

yderligere så vidt jeg husker gælder det også når man value overføre classer.

class a;

int noget(class b);

noget(a);

Det ser ud som om der er sket en fejl her paa siden

Alle felterne er tomme og jeg kan desvarre ikke laese de svar i har givet. Kan i laese dem og i saafald, kan i paste dem ind i et nyt?
Paa forhaand tak!

Jeg havde haabet paa at teksten vill dukke op igen, saa jeg kunne se jeres fra fra den 6/3 klokken 11.36.
Jeg har arbejdet videre paa mit projekt og har faaet lidt mere til at virke, men er desvaerre gaaet i staa.
Jeg har nu inkluderet alle de funktioner som skal vaere i projectet og min default constructor, set_time, samt advance functionerne virker.
Som i kan se se har jeg oprettet en function der hedder "printStandard ()", men det er kun en midlertidig loesning da jeg skal overloade output og input operatorer (hvilket jeg har gjort et forsoeg paa - uden held).
Derudover ved jeg ikke hvordan jeg skal kalde copy constructoren, samt disse functioner:
bool operator <(const clock& c1, const clock& c2);
clock operator +(const clock& c1, const clock& c2);
bool operator == (const clock& c1, const clock& c2);
Jeg haaber i kan hjaelpe mig.
Paa forhaand tak!


#include <cassert>
#include <iostream>        // Provides cout and cin
#include <fstream>
#include <iomanip>
#include <cstdlib>          // Provides EXIT_SUCCESS
using namespace std;        // Allows all Standard Library 
class clock
    {
    public:
        // CONSTRUCTOR
        clock( );// default constructor
    clock(clock& copyFrom);// copy constructor
        // MODIFICATION FUNCTIONS
        void set_time(int hour, int minute, bool morning);
        void advance(int minutes);
    // CONSTANT FUNCTIONS
        int get_hour( ) const;
        int get_minute( ) const;
        bool is_morning( ) const;
    void printStandard ();//Print standard time format
    friend istream& operator >>( istream& input, clock& time);
    private:
        int my_hour;
        int my_minute;
        int my_morning;
    };
    // NONMEMBER FUNCTION for the clock class:
        bool operator <(const clock& c1, const clock& c2);
        clock operator +(const clock& c1, const clock& c2);
        bool operator == (const clock& c1, const clock& c2);
        void printStandard ();//Print standard time format
        ostream& operator <<( ostream& output, clock& time);
       
int main( )
{
   
    clock sample;
    sample.printStandard();//initial standard time
    cout << endl;
    sample.set_time(9, 48, true);
    sample.printStandard();
    cout << c1;
    sample.advance(1500); // Add 1500 minutes
    cout << endl;
    sample.printStandard();
           
       
    return EXIT_SUCCESS;
}


    clock::clock( )
    {
        my_hour = 12;
        my_minute = 0;
        my_morning = true;
    }


    clock::clock(clock& copyFrom)
    {
    my_hour = copyFrom.get_hour();
    my_minute = copyFrom.get_minute();
    my_morning = copyFrom.is_morning();
    }

    void clock::set_time(int hour, int minute, bool morning)
    // Library facilities used: cassert
    {
        assert(1 <= hour);
        assert(hour <= 12);
        assert(0 <= minute);
        assert(minute <= 59);

        my_hour = hour;
        my_minute = minute;
        my_morning = morning;
    }
    void clock::advance(int minutes)
    {
        const int MINUTES_IN_DAY = 24*60;
        const int MINUTES_IN_HOUR = 60;

        // Change the minutes so that 0 <= minutes < MINUTES_IN_DAY
        if (minutes < 0)
            minutes += MINUTES_IN_DAY * (1 - minutes/MINUTES_IN_DAY);
        if (minutes >= MINUTES_IN_DAY)
            minutes -= MINUTES_IN_DAY * (minutes/MINUTES_IN_DAY);
   
        // Advance the clock any full hours
        while (minutes > 60)
        {
            minutes -= MINUTES_IN_HOUR;
            my_hour++;
            if (my_hour == 12)
            my_morning = !my_morning;
            if (my_hour == 13)
            my_hour = 1;
        }
   
        // Advance any remaining minutes
        my_minute += minutes;
        if (my_minute >= MINUTES_IN_HOUR)
        {
            my_minute -= MINUTES_IN_HOUR;
            my_hour++;
            if (my_hour == 12)
            my_morning = !my_morning;
            if (my_hour == 13)
            my_hour = 1;
        }
    }



    int clock::get_hour( ) const
    {
    return my_hour;
    }

    int clock::get_minute( ) const
    {
    return my_minute;
    }

    bool clock::is_morning( ) const
    {
    return my_morning;
    }
    // kun midlertidig function, da jeg skal overloade in/output
    void clock::printStandard()
    {
        cout << (( my_hour == 0 || my_hour == 12) ? 12 : my_hour % 12)
            << ":" << (my_minute < 10 ? "0" : "" ) << my_minute
            << ( my_hour < 12 ? " AM " : " PM " );
    }
   

    ostream& operator <<( ostream& outs, clock& time)
    {
    outs << time.get_hour()<< " " << time.get_minute();
    outs << time.is_morning();
    outs << (( time.get_hour() == 0 || time.get_hour() == 12) ? 12 : time.get_hour() % 12);
    outs << ":" << (time.get_minute() < 10 ? "0" : "" ) << time.get_minute();
    outs << ( time.get_hour() < 12 ? " AM " : " PM " );
    return outs; //enables cascading   
    }

    istream& operator >>(istream& ins, clock& target)
    {
        ins >> target.my_hour >> target.my_minute>>target.my_morning;
        return ins;//enables cascading;
    }


    bool operator <(const clock& c1, const clock& c2)
    {
    // Check whether one is morning and the other is not
    if (c1.is_morning( ) && !c2.is_morning( ))
        return true;
    else if (c2.is_morning( ) && !c1.is_morning( ))
        return false;

    // Check whether one is 12 o'clock and the other is not
    else if ((c1.get_hour( ) == 12) && (c2.get_hour( ) != 12))
        return true;
    else if ((c2.get_hour( ) == 12) && (c1.get_hour( ) != 12))
        return false;

    // Check whether the hours are different from each other
    else if (c1.get_hour( ) < c2.get_hour( ))
        return true;
    else if (c2.get_hour( ) < c1.get_hour( ))
        return false;

    // The hours are the same, so check the minutes
    else if (c1.get_minute( ) < c2.get_minute( ))
        return true;
    else
        return false;
    }

/*
clock operator +(const clock& c1, const clock& c2)
    {
    double x_total, y_total;
    // computes the x and y of the sum.
    x_total = (c1.get_minute () + c2.get_minute ());
    y_total = (c1.get_hour () + c2.get_hour ());
    clock total(x_total, y_total); //maaske return x_total, y_total
    return total;
/*

bool operator == (const clock& c1, const clock& c2)
{
    return
    (c1.get_hour () == c2.get_hour())
    &&
    (c1.get_minute () == c2.get_minute())
    &&
    (c1.is_morning () == c2.is_morning())
}

Hej,
Jeg har naesten loest projectet, men har lidt problemer med overloading += og +. Det er disse funktioner:
   
    void clock::operator +=(clock rhs)
{
    my_minute += rhs.my_minute;
    //current_minutes += rhs.current_minutes;
};
//**********************************************************************************
   
    void clock:: operator = (clock rhs)
{
    my_minute += rhs.my_minute;
    //current_minutes = rhs.current_minutes;
};

Er der en der har et overblik over hvad der er galt.

Jeg paster lige mit project, for jeg har lave en del om:

#include <cassert>
#include <iostream>        // Provides cout and cin
#include <fstream>
#include <iomanip>
#include <cstdlib>          // Provides EXIT_SUCCESS
using namespace std;        // Allows all Standard Library items to be used
class clock
    {
    public:
        // CONSTRUCTOR
        clock( );// default constructor
        clock(clock& copyFrom);// copy constructor
        // MODIFICATION FUNCTIONS
        void set_time(int hour, int minute, bool morning);
        void advance(int minutes);
        void clock:: operator +=(clock rhs);
        void clock:: operator = (clock rhs);
        // CONSTANT FUNCTIONS
        int get_hour( ) const;
        int get_minute( ) const;
        bool is_morning( ) const;
       
    private:
        int my_hour;
        int my_minute;
        int my_morning;
    };
    // NONMEMBER FUNCTION for the clock class:
        bool operator <(const clock& c1, const clock& c2);
        ostream& operator <<( ostream& output, clock& time);
       
int main( )
{
   
    clock sample;
    clock c1;
    clock c2;
    clock c3;
    cout << "The initial standard time: " <<endl;;
    cout << sample;//initial standard time
    cout <<endl;
    cout << "The time set to: ";
    sample.set_time(9, 48, true);// Set the time to 9:48:AM
    cout <<endl;
    cout << sample;
    cout <<endl;
    cout <<"Adding 1500 min. to 9:48 A.M: ";
    sample.advance(1500); // Add 1500 minutes
    cout << endl;
    cout<< sample;
    cout << endl;
    cout <<"Checking if it's earlier or later than noon: ";
    cout <<endl;
    c1.set_time (4, 56, true);
    c2.set_time (3, 45, true);
    operator <(c1, c2);
    if (c1 < c2)
        cout << "The time is earlier than noon!" << endl;
    else
        cout << "The time is past noon!" << endl;

    c1 += c2;
    cout << c1;
    c3 = c1;
    cout << c3;

       
    return EXIT_SUCCESS;
}

//**********************************************************************************
    clock::clock( )
    {
        my_hour = 12;
        my_minute = 0;
        my_morning = true;
    }

//**********************************************************************************
    clock::clock(clock& copyFrom)
    {
    my_hour = copyFrom.get_hour();
    my_minute = copyFrom.get_minute();
    my_morning = copyFrom.is_morning();
    }
//**********************************************************************************
    void clock::set_time(int hour, int minute, bool morning)
    // Library facilities used: cassert
    {
        assert(1 <= hour);
        assert(hour <= 12);
        assert(0 <= minute);
        assert(minute <= 59);

        my_hour = hour;
        my_minute = minute;
        my_morning = morning;
    }
//**********************************************************************************
    void clock::advance(int minutes)
    {
        const int MINUTES_IN_DAY = 24*60;
        const int MINUTES_IN_HOUR = 60;

        // Change the minutes so that 0 <= minutes < MINUTES_IN_DAY
        if (minutes < 0)
            minutes += MINUTES_IN_DAY * (1 - minutes/MINUTES_IN_DAY);
        if (minutes >= MINUTES_IN_DAY)
            minutes -= MINUTES_IN_DAY * (minutes/MINUTES_IN_DAY);
   
        // Advance the clock any full hours
        while (minutes > 60)
        {
            minutes -= MINUTES_IN_HOUR;
            my_hour++;
            if (my_hour == 12)
            my_morning = !my_morning;
            if (my_hour == 13)
            my_hour = 1;
        }
   
        // Advance any remaining minutes
        my_minute += minutes;
        if (my_minute >= MINUTES_IN_HOUR)
        {
            my_minute -= MINUTES_IN_HOUR;
            my_hour++;
            if (my_hour == 12)
            my_morning = !my_morning;
            if (my_hour == 13)
            my_hour = 1;
        }
    }

//**********************************************************************************
    int clock::get_hour( ) const
    {
    return my_hour;
    }
//**********************************************************************************
    int clock::get_minute( ) const
    {
    return my_minute;
    }
//**********************************************************************************
    bool clock::is_morning( ) const
    {
    return my_morning;
    }
   
    ostream& operator <<( ostream& outs, clock& time);
//**********************************************************************************
    ostream& operator <<( ostream& outs, clock& time)
    {
    //const char BLANK= '';
    //outs << BLANK;
    outs << (( time.get_hour() == 0 || time.get_hour() == 12) ? 12 : time.get_hour() % 12);
    outs << ":" << (time.get_minute() < 10 ? "0" : "" ) << time.get_minute();
    outs << ( time.get_hour() < 12 ? " AM " : " PM " );
    return outs; //enables cascading   
    }



//**********************************************************************************
    bool operator <(const clock& c1, const clock& c2)
    {
    // Check whether one is morning and the other is not
    if (c1.is_morning( ) && !c2.is_morning( ))
        return true;
    else if (c2.is_morning( ) && !c1.is_morning( ))
        return false;

    // Check whether one is 12 o'clock and the other is not
    else if ((c1.get_hour( ) == 12) && (c2.get_hour( ) != 12))
        return true;
    else if ((c2.get_hour( ) == 12) && (c1.get_hour( ) != 12))
        return false;

    // Check whether the hours are different from each other
    else if (c1.get_hour( ) < c2.get_hour( ))
        return true;
    else if (c2.get_hour( ) < c1.get_hour( ))
        return false;

    // The hours are the same, so check the minutes
    else if (c1.get_minute( ) < c2.get_minute( ))
        return true;
    else
        return false;
    }
//**********************************************************************************
   
    void clock::operator +=(clock rhs)
{
    my_minute += rhs.my_minute;
    //current_minutes += rhs.current_minutes;
};
//**********************************************************************************
   
    void clock:: operator = (clock rhs)
{
    my_minute += rhs.my_minute;
    //current_minutes = rhs.current_minutes;
};

//**********************************************************************************

Jeg valgte at give jer 100 points hver. Nu fik jeg selv loest det det meste, men jeg saetter pris paa at i sidder og hjaelper folk som mig.
Jeg takker!