C Review User Defined Types Builtin data types
C++ Review
User Defined Types • Built-in data types are simple. Specific problems may demand aggregate/more complex data types. – Ex: polygons, matrices, car specifications, etc… • Types define both data and operations that can be performed on that data – Ex: vectors might store x, y coordinates and have addition/subtraction operations • C++ allows for complex types in the form of classes and structs
Class Example struct Point { float m_x, m_y; void Set ( float x, float y ) { m_x = x; m_y = y; } }; class Point { float m_x, m_y; public: void Set ( float x, float y ) { m_x = x; m_y = y; } }; In C++, the only difference between struct/class is public/private scope
Public, Protected, Private Scopes • Public: functions/data that any part of a program may access – Ex: Data Accessors – Get. Data(), modifiers – Set. Data(new. Data), operations – Action. X() • Protected: functions/data that only the class and any derived subclasses may access – Ex: Helper functions for operations. Most data in class hierarchies • Private: functions/data that only the class itself may access – Ex: Helper functions and some data
Encapsulation • A mechanism for restricting access to some of the object's components • Advice: – Helper functions and data should be “Encapsulated”, i. e. , should be private or protected – Use Accessors/Modifiers to “Get”/“Set” the data
Constructors and Destructors • Constructors – “functions” that define how data is initialized – Same name as the class itself – Default constructor – takes no parameters, e. g. , Point() – Copy constructor – takes an object of the class itself to initialize the data, e. g. , Point(old. Point) • Destructors – define how data is deleted – Same name as the class except with a ~, e. g. , ~My. Class() – Usually not called in code you write. The compiler automatically calls it when an object is deleted.
Abstract Types and Hierarchies • Often many types have things in common, e. g. , all shapes can be drawn or all shapes have color • However, you cannot concretely define a shape. In this case a shape is abstract • We derive more concrete classes off of abstract ones, e. g. , a circle is a concrete shape
Inheritance • Inheritance allows reuse of code in existing objects and definition of subtypes Shape Circle Square Triangle
Inheritance • Inheritance allows reuse of code in existing objects and definition of subtypes Base class: class that is inherited from Shape Circle Square Triangle
Inheritance • Inheritance allows reuse of code in existing objects and definition of subtypes Derived class: class that does the inheriting Shape Circle Square Triangle
Inheritance • Inheritance allows reuse of code in existing objects and definition of subtypes Derived class: class that does the inheriting Shape Circle Square Triangle • Derived classes have access to public/protected data and functions of the base class
Inheritance Example class Shape { protected: Color m_c; public: Shape(Color c) : m_c(c) {} class Circle : public Shape { float m_radius; public: Circle(Color c, float r) : Shape(c), m_radius(r) {} void Draw() {/*do nothing*/} }; void Draw() {/*draw circle of radius r*/} }; class Square : public Shape { float m_side; public: Square(Color c, float s) : Shape(c), m_side(s) {} void Draw() {/*draw circle of radius r*/} };
Virtual Functions • Function whose behavior can be overridden in a derived class. • A call to a virtual function will call the function of the original object regardless of the type of the pointer. class Shape { protected: Color m_c; public: Shape(Color c) : m_c(c) {} // pure virtual function virtual void Draw() = 0; }; class Circle : public Shape { float m_radius; public: Circle(Color c, float r) : Shape(c), m_radius(r) {} virtual void Draw() {/*draw circle of radius r*/} };
Virtual Functions • Function whose behavior can be overridden in a derived class. • A call to a virtual function will call the function of the original object regardless of the type of the pointer. class Shape { protected: Color m_c; public: Shape(Color c) : m_c(c) {} // pure virtual function virtual void Draw() = 0; }; class Circle : public Shape { float m_radius; public: Circle(Color c, float r) : Shape(c), m_radius(r) {} virtual void Draw() {/*draw circle of radius r*/} }; Requires derived classes to implement this function.
Virtual Functions • Function whose behavior can be overridden in a derived class. • A call to a virtual function will call the function of the original object regardless of the type of the pointer. class Shape { protected: Color m_c; public: Shape(Color c) : m_c(c) {} // pure virtual function virtual void Draw() = 0; }; class Circle : public Shape { float m_radius; public: Circle(Color c, float r) : Shape(c), m_radius(r) {} virtual void Draw() {/*draw circle of radius r*/} }; Classes with pure virtual functions are abstract and cannot be instantiated.
Virtual Functions • Function whose behavior can be overridden in a derived class. • A call to a virtual function will call the function of the original object regardless of the type of the pointer. class Shape { protected: Color m_c; public: Shape(Color c) : m_c(c) {} // pure virtual function virtual void Draw() = 0; }; class Circle : public Shape { float m_radius; public: Circle(Color c, float r) : Shape(c), m_radius(r) {} virtual void Draw() {/*draw circle of radius r*/} }; Shape *s = new Circle ( Red, 1. 0 f ); s->Draw ( ); // calls Circle: Draw ( )
Virtual Functions • Function whose behavior can be overridden in a derived class. • A call to a virtual function will call the function of the original object regardless of the type of the pointer. class Shape { protected: Color m_c; public: Shape(Color c) : m_c(c) {} class Circle : public Shape { float m_radius; public: Circle(Color c, float r) : Shape(c), m_radius(r) {} void Draw() {/*do nothing*/} virtual void Draw() {/*draw circle of radius r*/} }; }; Shape *s = new Circle ( Red, 1. 0 f ); s->Draw ( ); // calls Shape: Draw ( )
Operator Overloading • Operator overloading provides a way to use common operators with user defined types – Ex: assignment (=), addition (+), input (>>) class My. Class{ private: string m_name; public: My. Class(string name) : m_name(name) {} My. Class& operator=(const My. Class& m) { m_name = m. m_name; } };
Exercises 1. Create a struct called Point. This will be a 2 D point. Provide a constructor, overloaded assignment operator, and public data. 2. Create an abstract class called Shape will have protected data of a Point describing the location of the shape and a pure virtual function Print(). 3. Create subclasses of Shape, Circle and Square with private data. Overload the print function to print out the type and data members of the class. For example, Circle: : Print () might output “Circle at position 3, 5 with radius 2”. 4. Create a main function instantiating a Square and a Circle as an abstract Shape. Call the virtual function of Shape.
- Slides: 19