CD5250 - Objektorienterad programutveckling med C++, 5 poäng, period 3, 2002

Size-klassen

intro

På föreläsningarna har vi gått igenom olika konstruktioner i C++ såsom klasser, olika konstruktorer, operatoröverlagring, friend-funktioner m.m. och vi har ofta haft klassen Size som exempel. Nedan finner ni en sammanställning med många av dessa lösa exempel och som sammanlagt bildar en ganska kompetent Size-klass.

Klassen och även en demonstration av klassen finns att ladda ned här:

  • Size.h
  • Size.cpp
  • main.cpp
  • A. Size.h

    #ifndef SIZE_H
    #define SIZE_H
    
    #include <iostream>
    
    class Size
    {
    public:
    	// konstruktor som initierar objektet med koordinater
    	// som skickas via parametrar
    	Size(int width, int height);
    
    	// defaultkonstruktor
    	// initierar objektet till att vara av storlek (0,0)
    	Size();
    
    	// tilldelningskonstruktor
    	// kopiera innehållet från s till this
    	Size(Size const & s);
    
    	// dessa funktioner är så korta att det passar att
    	// även DEFINIERA metoderna här i H-filen
    	void SetWidth(int width) { m_height = width; }
    	void SetHeight(int height) { m_height = height; }
    	int GetWidth() { return m_width; }
    	int GetHeight() { return m_height; }
    	// returnera arean som objektet spänner upp
    	int Area() { return m_width*m_height; }
    
    	// jämför två Size-objekt
    	// metoden är const eftersom inte "this" ändras
    	// parametern "s" är const eftersom den inte ändras
    	bool operator==(Size const & s) const;
    	// jämför för olikhet
    	bool operator!=(Size const & s) const;
    
    	// kopiera innehållet från "s" till "this"
    	// denna operatoröverlagring är egentligen onödig eftersom
    	// standardbeteendet är detsamma som det vi inför här, dvs
    	// kopiering av varje enskilt element.
    	Size & operator=(Size const & s);
    
    	// -----------
    	// + operatorn har vi hoppat över eftersom det inte finns
    	// något uppenbart beteende för en addition av två Size.
    	// -----------
    	
    	// däremot kan vi implementera *= operatorn, som vi definierar
    	// som en skalning av storleken. Argumentet till operatorn
    	// är en float som bestämmer skalningsfaktorn.
    	Size & operator*=(float scale);
    
    	// operatorn för skalningsmultiplikation "*" är enkel att
    	// införa nu när "*=" redan finns färdig
    	// Observera! hela det temporära objektet returneras, inte
    	// bara en referens!
    	// metoden är const eftersom objektet inte skall ändras vid
    	// multiplikationen. endast det temporära objektet som returneras
    	// kommer att modifieras i metoden
    	Size operator*(float scale) const;
    
    	// för att vi även skall kunna skala Size-objekt på följande format
    	// "0.5 * size" måste vi göra en friendfunktion som tar två parametrar
    	// Observera! vi returnerar ett helt objekt eftersom uttrycket skall
    	// ge ett nytt Size-objekt
    	friend Size operator*(float scale, Size const & size);
    
    	// denna operator utökar funktionaliteten för ostream-objekt (t.ex. cout)
    	// därigenom skall vi kunna skriva ut Size-objekt med "cout << size"
    	// Observera! vi returnerar en referens till det objekt vi får in som
    	// första parameter. Detta för att vi vill kunna länka ihop uttryck som
    	// t.ex "cout << "Storlek1: " << size1 << " Storlek2: " << size2;"
    	// Observera även! vi använder inte "using namespace std;" pga bugg
    	// i Microsofts kompilator. Vi använder istället "std::"
    	friend std::ostream & operator<<(std::ostream & o, Size const & size);
    
    protected:
    	// datamedlemmar bredd och höjd
    	int m_width;
    	int m_height;
    };
    
    #endif // SIZE_H
    
    Exempel 1.Size.cpp

    B. Size.cpp

    #include "Size.h"
    
    // konstruktor som initierar objektet med koordinater
    // som skickas via parametrar
    Size::Size(int width, int height)
    {
    	m_width = width;
    	m_height = height;
    }
    
    // defaultkonstruktor
    // initierar objektet till att vara av storlek (0,0)
    Size::Size()
    {
    	m_width = m_height = 0;
    }
    
    // tilldelningskonstruktor
    // kopiera innehållet från s till this
    Size::Size(Size const & s)
    {
    	// vi använder oss av tilldelningsoperatorn som finns
    	// deklarerad längre ned i klassen
    	*this = s;
    }
    
    // jämför två Size-objekt
    // metoden är const eftersom inte "this" ändras
    // parametern "s" är const eftersom den inte ändras
    bool Size::operator==(Size const & s) const
    {
    	// jämför höjd och bredd
    	if (m_width == s.m_width && m_height == s.m_height)
    		return true;
    	else
    		return false;
    }
    
    // jämför för olikhet
    bool Size::operator!=(Size const & s) const
    {
    	// vi anropar "=="-operatorn och returnerar tvärt emot
    	if (*this == s)
    		return false;
    	else
    		return true;
    }
    
    // kopiera innehållet från "s" till "this"
    // denna operatoröverlagring är egentligen onödig eftersom
    // standardbeteendet är detsamma som det vi inför här, dvs
    // kopiering av varje enskilt element.
    // standardbeteende är att metoden returnerar sig själv
    Size & Size::operator=(Size const & s)
    {
    	m_width = s.m_width;
    	m_height = s.m_height;
    	return *this;
    }
    
    // -----------
    // + operatorn har vi hoppat över eftersom det inte finns
    // något uppenbart beteende för en addition av två Size.
    // -----------
    
    // däremot kan vi implementera *= operatorn, som vi definierar
    // som en skalning av storleken. Argumentet till operatorn
    // är en float som bestämmer skalningsfaktorn.
    Size & Size::operator*=(float scale)
    {
    	m_width *= scale;
    	m_height *= scale;
    	return *this;
    }
    
    // operatorn för skalningsmultiplikation "*" är enkel att
    // införa nu när "*=" redan finns färdig
    // Observera! hela det temporära objektet returneras, inte
    // bara en referens!
    Size Size::operator*(float scale) const
    {
    	// kopiera innehållet i this genom dess tilldelningsKONSTRUKTOR
    	Size temp = *this;
    
    	// här använder vi den redan definierade "*=" operatorn för size
    	temp *= scale;
    	return temp;
    }
    
    // för att vi även skall kunna skala Size-objekt på följande format
    // "0.5 * size" måste vi göra en friendfunktion som tar två parametrar
    // Observera! vi returnerar ett helt objekt eftersom uttrycket skall
    // ge ett nytt Size-objekt
    // OBS! i definitionen är inte friend-uttrycket med!
    Size operator*(float scale, Size const & size)
    {
    	// kopiera "size" eftersom "size" inte skall ändras
    	Size temp = size;
    	temp.m_width *= scale;
    	temp.m_height *= scale;
    
    	// returnera det skalade objektet
    	return temp;
    }
    
    /*
    // nedan följer en alternativ metod för att definiera "*"-operatorn
    // vilken är att föredra framför den andra eftersom den både blir
    // kortare och det blir mindre ställen i koden där medlemsvariablerna
    // hanteras
    Size Size::operator*(float scale, Size const & size)
    {
    	return size * scale;
    }
    */
    
    // denna operator utökar funktionaliteten för ostream-objekt (t.ex. cout)
    // därigenom skall vi kunna skriva ut Size-objekt med "cout << size"
    // Observera! vi returnerar en referens till det objekt vi får in som
    // första parameter. Detta för att vi vill kunna länka ihop uttryck som
    // t.ex "cout << "Storlek1: " << size1 << " Storlek2: " << size2;"
    // Observera även! vi använder inte "using namespace std;" pga bugg
    // i Microsofts kompilator. Vi använder istället "std::"
    std::ostream & operator<<(std::ostream & o, Size const & size)
    {
    	o << "(" << size.m_width << "," << size.m_height << ")";
    	return o;
    }
    
    Exempel 2.Size.cpp
    Aktuellt
    Utvärdering2
    Nyheter
    Föreläsning 14
    Laboration 6
    Projektuppgift
    CD5250
    Nyheter
    Kursinformation
    Föreläsningar
    Labbar
    Projektuppgift
    C --> C++
    STL-intro
    Size-klassen
    Utvärdering
    Utvärdering2
    Visual C++
    Kursplan
    Schema
    Underrubriker
    Size.h
    Size.cpp
    Ansvarig lärare: Martin Skogevall - martin.skogevall@mdh.se
    Senast uppdaterad: Tue Mar 05 16:57:48 GMT+01:00 2002