week 14 wednesday n.
Download
Skip this Video
Download Presentation
CS222

Loading in 2 Seconds...

play fullscreen
1 / 38

CS222 - PowerPoint PPT Presentation


  • 145 Views
  • Uploaded on

Week 14 - Wednesday. CS222. Last time. What did we talk about last time? More C++ new d elete Differences for structs Lab 13. Questions?. Project 6. Quotes.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'CS222' - ledell


Download Now An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
last time
Last time
  • What did we talk about last time?
  • More C++
    • new
    • delete
    • Differences for structs
  • Lab 13
quotes
Quotes

If you think C++ is not overly complicated, just what is a protected abstract virtual base pure virtual private destructor, and when was the last time you needed one?

Tom Cargill

c warmup
C++ Warmup
  • Let's write a complete C++ program that reads in:
    • A string
    • An integer
  • Then, it prints out the string however many times the integer specified
object oriented programming
Object Oriented Programming
  • Let's see how objects work in C++ by looking at classically important elements of OOP
    • Encapsulation
    • Dynamic dispatch
    • Polymorphism
    • Inheritance
    • Self-reference
encapsulation
Encapsulation
  • Information hiding
  • We want to bind operations and data tightly together
  • Consequently, we don't want you to touch our privates
  • Encapsulation in C++ is provided by the private and protected keywords
    • Unlike Java, you mark sections as public, private, or protected, not individual members and methods
  • Hardcore OOP people think that all data should be private and most methods should be public
encapsulation example
Encapsulation example

class A

{

private:

int a;

public:

intgetA()

{

return a;

}

voidsetA(int value)

{

a = value;

}

};

inheritance
Inheritance
  • Allows code reuse
  • Is thought of as an "is-a" relationship
  • C++ allows multiple inheritance, but you usually only use it if you know what you're doing, usually as part of a design pattern
  • Deriving a subclass usually means creating a "refined" or "more specific" version of a superclass
inheritance example
Inheritance example

class B : public A

{ //has member and methods from A

};

class C : public A

{

private: //has A stuff and more

intc;

public:

intgetC(){ return c; }

void increment() { c++; }

};

polymorphism
Polymorphism
  • A confusing word whose underlying concept many programmers misunderstand
  • Polymorphism is when code is designed for a superclass but can be used with a subclass
  • If AudiRS5 is a subtype of Car, then you can use an AudiRS5 where you could use a Car
polymorphism example
Polymorphism example

void drive( Car* c );

//defined somewhere

class AudiRS5 : public Car

{};

Car car;

AudiRS5 audi;

drive( &audi ); //okay

drive( &car ); //okay

dynamic dispatch
Dynamic dispatch
  • Polymorphism can be used to extend the functionality of an existing method using dynamic dispatch
  • In dynamic dispatch, the method that is actually called is not known until run time
dynamic dispatch example
Dynamic dispatch example

class A {

public: virtualvoid print()

{ cout << "A"; }

};

class B : public A

{

public: void print()

{ cout << "B"; }

};

dynamic dispatch example1
Dynamic dispatch example

A a;

B b;

A* p;

a.print(); // A

b.print(); // B

p = &a;

p->print(); // A

p = &b;

p->print(); // B

self reference
Self-reference
  • Objects are able to refer to themselves
  • This can be used to explicitly reference variables in the class
  • Or, it can be used to provide the object itself as an argument to other methods
  • Self-reference in C++ is provided in part through the this keyword
    • this is a pointer to the object you're inside of
self reference example
Self reference example

class Stuff

{

private:

int things;

public:

voidsetThings(int things)

{

this->things = things;

}

};

self reference example1
Self reference example

classSelfAdder

{

public:

voidaddToList(List& list)

{

list.add(this);

}

};

dividing up code
Dividing up code
  • In industrial strength C++ code, the class declaration is usually put in a header file (.h) while the class definition is in an implementation file (.cpp)
  • Benefits:
    • Easy to see members and methods
    • Header files can be sent to clients without divulging class internals
    • Separate compilation (faster)
    • Easier to take care of circular dependencies
dividing up code header
Dividing up code header

class Complex

{

double real;

double imaginary;

public:

Complex(doublerealValue = 0, doubleimaginaryValue = 0);

~Complex(void);

doublegetReal();

doublegetImaginary();

};

dividing up code implementation
Dividing up code implementation

Complex::Complex(doublerealValue, doubleimaginaryValue)

{

real = realValue;

imaginary = imaginaryValue;

}

Complex::~Complex(void)

{}

double Complex::getReal()

{ return real; }

double Complex::getImaginary()

{ return imaginary; }

overloading operators
Overloading operators
  • In C++, you can overload operators, meaning that you can define what + means when used with classes you design
  • Thus, the following could be legal:

Hippopotamus hippo;

Sandwich club;

Vampiredracula = club + hippo;

overloading operators1
Overloading operators
  • But, what does it mean to "add" a Hippopotamus to a Sandwich and get a Vampire?
  • Overloading operators is a bad idea
  • You can get confusing code
  • Most languages don't allow it
  • It C++ it is useful in two cases:
    • To make your objects easy to input/output using iostream
    • To perform mathematical operations with numerical classes (like Complex!)
partial overloading operators header
(Partial) overloading operators header

Complex& operator=( const Complex& complex );

Complex operator+( const Complex& complex ) const;

Complex operator-( const Complex& complex ) const;

Complex operator-() const;

Complex operator*( const Complex& complex ) const;

partial overloading operators implementation
(Partial) overloading operators implementation

Complex& Complex::operator=

( const Complex& complex )

{

real = complex.real;

imaginary = complex.imaginary;

return *this;

}

what s all that const
What's all that const?
  • const, of course, means constant in C++
  • In class methods, you'll see several different usages
  • Const methods make a guarantee that they will not change the members of the object they are called on
    • intcountCabbages() const;
  • Methods can take const arguments
    • void insert(const Coin money);
  • Methods cant take const reference arguments
    • void photograph(const Castle& fortress);
  • Why take a const reference when references are used to change arguments?
templates1
Templates
  • Allow classes and functions to be written with a generic type or value parameter, then instantiated later
  • Each necessary instantiation is generated at compile time
  • Appears to function like generics in Java, but works very differently under the covers
  • Most of the time you will use templates, not create them
template method example
Template method example

template<class T> void exchange(T& a, T& b )

{

T temp = a;

a = b;

b = temp;

}

template classes
Template classes
  • You can make a class using templates
  • The most common use for these is for container classes
    • e.g. you want a list class that can be a list of anything
  • The STL filled with such templates
  • Unfortunately, template classes must be implemented entirely in the header file
    • C++ allows template classes to be separate from their headers, but no major compiler fully supports it
template class example
Template class example

template<class T> class Pair {

private:

T x;

T y;

public:

Pair( const T& a, const T& b ) {

x = a;

y = b;

}

T getX() const { return x; }

T getY() const { return y; }

void swap() {

T temp = x;

x = y;

y = temp;

}

};

next time
Next time…
  • STL
  • Lab 14
reminders
Reminders
  • Keep working on Project 6
    • Due next Friday