11/1/2014

A Rahman
From Representing a (Geometric) Vector
• In the context of geometry, a
vector consists of 2 points: a
start and a finish
To • Each point itself has an x and y
coordinate End =
(0.9, 1.5)

Start =
(0.4, 0.8)
CSE 109

Representing a (Geometric) Vector

• Our representation so far? Use
4 doubles (startx, starty, endx,
endy) End =
(2.0, 1.6)
• We need to pass all 4 doubles
to functions End = int main() {
double xStart = 1.2;
(0.9, 1.5) double xEnd = 2.0;
double yStart = 0.4; Start =
double yEnd = 1.6; (1.2, 0.4)
}
Start =
(0.4, 0.8)

1
 11/1/2014

void offsetVector(double &x0, double &x1, double &y0, double &y1,

double offsetX, double offsetY) {
x0 += offsetX;
x1 += offsetX;
y0 += offsetY;
y1 += offsetY;
}

void printVector(double x0, double x1, double y0, double y1) { void printVector(double x0, double x1, double y0, double y1) {
cout << "(" << x0 << "," << y0 << ") -> (" cout << "(" << x0 << "," << y0 << ") -> ("
<< x1 << "," << y1 << ")" << endl; << x1 << "," << y1 << ")" << endl;
} }

int main() { int main() {

double xStart = 1.2; double xStart = 1.2;
double xEnd = 2.0; double xEnd = 2.0;
double yStart = 0.4; double yStart = 0.4;
double yEnd = 1.6; double yEnd = 1.6;
printVector(xStart, xEnd, yStart, yEnd); offsetVector(xStart, xEnd, yStart, yEnd, 1.0, 1.5);
// (1.2,2.0) -> (0.4,1.6) printVector(xStart, xEnd, yStart, yEnd); Many variables being passed to
} // (2.2,1.9) -> (3.8,4.3) functions
}

class class definition syntax

• A user-defined datatype which groups
together related pieces of information
name

class Vector {
Vector public:
double xStart;
double xEnd;
double yStart;
double yEnd;
xStart xEnd yStart yEnd
};

• This indicates that the new datatype we’re

defining is called Vector

2
 11/1/2014

class definition syntax Fields can have different types

MITStudent
class Vector { class MITStudent {
public: public:
double xStart; char *name; name studentID
double xEnd; int studentID;
double yStart; fields };
double yEnd;
};

• Fields indicate what related pieces of

information our datatype consists of
- Another word for field is members

Instances Declaring an Instance

• Defines 2 instances of MITStudent: one called
• An instance is an occurrence of a class. student1, the other called student2
Different instances can have their own set of class MITStudent {
public:
student1

values in their fields. char *name;

int studentID; name studentID
• If you wanted to represent 2 different };
=? =?
students (who can have different names and int main() {
MITStudent student1;
IDs), you would use 2 instances of MITStudent MITStudent student2;
} student2
student1 student2

name studentID
name studentID name studentID =? =?
=? =? =? =?

3
 11/1/2014

Accessing Fields Accessing Fields

• To access fields of instances, use • To access fields of instances, use
variable.fieldName variable.fieldName
class MITStudent { student1 class MITStudent { student1
public: public:
char *name; char *name;
int studentID; name studentID int studentID; name studentID
}; };
= “Ayaan” =? = “Ayaan” = 123456789
int main() { int main() {
MITStudent student1; MITStudent student1;
MITStudent student2; MITStudent student2;
student1.name = “Ayaan"; student2 student1.name = “Ayaan"; student2
} student1.studentID = 123456789;
}
name studentID name studentID
=? =? =? =?

Accessing Fields Accessing Fields

• To access fields of instances, use • To access fields of instances, use
variable.fieldName variable.fieldName
class MITStudent { student1 class MITStudent {
public: public:
char *name; char *name;
int studentID; name studentID int studentID;
}; };
= “Ayaan” = 123456789
int main() { int main() {
MITStudent student1; MITStudent student1;
MITStudent student2; MITStudent student2;
student1.name = “Ayaan"; student2 student1.name = “Ayaan";
student1.studentID = 123456789; student1.studentID = 123456789;
student2.name = “Adrita"; student2.name = “Adrita";
student2.studentID = 987654321; name studentID student2.studentID = 987654321;
} = “Adrita” = 987654321 cout << "student1 name is" << student1.name << endl;
cout << "student1 id is" << student1.studentID << endl;
cout << "student2 name is" << student2.name << endl;
cout << "student2 id is" << student2.studentID << endl;

4
 11/1/2014

• A point consists of an x and y • A point consists of an x and y

coordinate class Vector {
coordinate
public:
• A vector consists of 2 points: a double xStart; • A vector consists of 2 points: a
double xEnd;
start and a finish double yStart;
start and a finish
double yEnd;
};

Vector

End = xStart xEnd yStart yEnd

End =
(0.9, 1.5) (0.9, 1.5)

Start = Start =
(0.4, 0.8) (0.4, 0.8)

• A point consists of an x and y • A point consists of an x and y

class Vector {
coordinate class Point {
coordinate
public: public:
double xStart; • A vector consists of 2 points: a double x; • A vector consists of 2 points: a
double xEnd;
double yStart;
start and a finish };
double y;
start and a finish
double yEnd;
}; Doesn’t show that coordinates
can be grouped into points
Vector

xStart xEnd yStart yEnd

End = End =
(0.9, 1.5) (0.9, 1.5)
Point

Start = x y Start =
(0.4, 0.8) (0.4, 0.8)

5
 11/1/2014

• A point consists of an x and y • A point consists of an x and y

class Point {
coordinate class Point {
coordinate
public: public:
double x; • A vector consists of 2 points: a double x; • A vector consists of 2 points: a
};
double y;
start and a finish };
double y;
start and a finish
class Vector {
public:
Point start;
Point end; Fields can be classes
};

Vector Vector

Point Point (start) Point (end)

Point Point (start) Point (end)

x y x y x y x y x y x y

class Point { vec1 (instance of Vector)

class Point { vec1 (instance of Vector)
public: public:
double x, y; double x, y;
}; start (instance of Point) end (instance of Point) }; start (instance of Point) end (instance of Point)

class Vector { x=? y=? x=? y=? class Vector { x=3 y=? x=? y=?
public: public:
Point start, end; Point start, end;
}; };

int main() { int main() {

Vector vec1; Vector vec1;
} vec1.start.x = 3.0;
}

6
 11/1/2014

class Point { vec1 (instance of Vector)

class Point { vec1 (instance of Vector)
public: public:
double x, y; double x, y;
}; start (instance of Point) end (instance of Point) }; start (instance of Point) end (instance of Point)

class Vector { x=3 y=4 x=5 y=6 class Vector { x=3 y=4 x=5 y=6
public: public:
Point start, end; Point start, end;
}; };
vec2 (instance of Vector)
int main() { int main() {
Vector vec1; Vector vec1; start (instance of Point) end (instance of Point)
vec1.start.x = 3.0; vec1.start.x = 3.0;
vec1.start.y = 4.0; vec1.start.y = 4.0; x=? y=? x=? y=?
vec1.end.x = 5.0; vec1.end.x = 5.0;
vec1.end.y = 6.0; vec1.end.y = 6.0;
} Vector vec2;
}

class Point { vec1 (instance of Vector)

class Point { vec1 (instance of Vector)
public: public:
double x, y; double x, y;
}; start (instance of Point) end (instance of Point) }; start (instance of Point) end (instance of Point)

class Vector { x=3 y=4 x=5 y=6 class Vector { x=3 y=4 x=5 y=6
public: public:
Point start, end; Point start, end;
}; };
vec2 (instance of Vector) vec2 (instance of Vector)
int main() { int main() {
Vector vec1; start (instance of Point) end (instance of Point) Vector vec1; start (instance of Point) end (instance of Point)
vec1.start.x = 3.0; vec1.start.x = 3.0;
vec1.start.y = 4.0; x=3 y=4 x=? y=?
vec1.start.y = 4.0; x=7 y=4 x=? y=?
vec1.end.x = 5.0; vec1.end.x = 5.0;
vec1.end.y = 6.0; vec1.end.y = 6.0;
Vector vec2; Vector vec2;
vec2.start = vec1.start; vec2.start = vec1.start;
} vec2.start.x = 7.0;
}
• Assigning one instance to another copies all fields • Assigning one instance to another copies all fields

7
 11/1/2014

Passing classes to functions Passing classes to functions

• Passing by value passes a copy of the class instance • When a class instance is passed by reference,
to the function; changes aren’t preserved changes are reflected in the original
class Point { public: double x, y; }; class Point { public: double x, y; };

void offsetPoint(Point p, double x, double y) { // does nothing void offsetPoint(Point &p, double x, double y) { // works
p.x += x; p.x += x;
p.y += y; p.y += y; Passed by
} } reference

int main() { int main() {

Point p; Point p;
p.x = 3.0; p.x = 3.0;
p.y = 4.0; p.y = 4.0;
offsetPoint(p, 1.0, 2.0); // does nothing offsetPoint(p, 1.0, 2.0); // works
cout << "(" << p.x << "," << p.y << ")"; // (3.0,4.0) cout << "(" << p.x << "," << p.y << ")"; // (4.0,6.0)
} }

class Point {
public: double x, y; Point class, with fields x and y
};

What we have learned so far?

8
 11/1/2014

class Point { class Point {

public: double x, y; public: double x, y;
}; };
class Vector { class Vector {
public: Point start, end; Fields can be classes public: Point start, end;
}; };

int main() {
Vector vec; vec is an instance of Vector
}

class Point { class Point {

public: double x, y; public: double x, y;
}; };
class Vector { class Vector {
public: Point start, end; public: Point start, end;
}; };

int main() { int main() {

Vector vec; Vector vec;
vec.start.x = 1.2; Accessing fields vec.start.x = 1.2; vec.end.x = 2.0; vec.start.y = 0.4; vec.end.y = 1.6;
} }

9
 11/1/2014

class Point { class Point {

public: double x, y; public: double x, y;
}; };
class Vector { class Vector {
public: Point start, end; public: Point start, end;
}; };

Can pass to value if you don’t

need to modify the class

void printVector(Vector v) { void printVector(Vector v) {

cout << "(" << v.start.x << "," << v.start.y << ") -> (" << v.end.x << cout << "(" << v.start.x << "," << v.start.y << ") -> (" << v.end.x <<
"," << v.end.y << ")" << endl; "," << v.end.y << ")" << endl;
} }

int main() { int main() {

Vector vec; Vector vec;
vec.start.x = 1.2; vec.end.x = 2.0; vec.start.y = 0.4; vec.end.y = 1.6; vec.start.x = 1.2; vec.end.x = 2.0; vec.start.y = 0.4; vec.end.y = 1.6;
printVector(vec); // (1.2,0.4) -> (2.0,1.6) printVector(vec); // (1.2,0.4) -> (2.0,1.6)
} }
classes can be passed
to functions

class Point {

};
public: double x, y; • Observe how some functions are closely
class Vector { associated with a particular class
public: Point start, end;
};
Pass classes by reference if they need to be modified
void offsetVector(Vector &v, double offsetX, double offsetY) {
v.start.x += offsetX;
v.end.x += offsetX;
v.start.y += offsetY; void offsetVector(Vector &v, double offsetX, double offsetY);
v.end.y += offsetY; void printVector(Vector v);
}
void printVector(Vector v) {
cout << "(" << v.start.x << "," << v.start.y << ") -> (" << v.end.x <<
"," << v.end.y << ")" << endl;
int main() {
} Vector vec;
vec.start.x = 1.2; vec.end.x = 2.0;
int main() { vec.start.y = 0.4; vec.end.y = 1.6;
Vector vec; offsetVector(vec,1.0, 1.5);
vec.start.x = 1.2; vec.end.x = 2.0; vec.start.y = 0.4; vec.end.y = 1.6; printVector(vec);
offsetVector(vec,1.0, 1.5); }
printVector(vec); // (2.2,1.9) -> (3.8,4.3)
}

10
 11/1/2014

• Observe how some functions are closely • Observe how some functions are closely
associated with a particular class associated with a particular class
• Methods: functions which are part of a class • Methods: functions which are part of a class
- Implicitly pass the current instance

Vector vec; Vector vec;

vec.start.x = 1.2; vec.end.x = 2.0; vec.start.x = 1.2; vec.end.x = 2.0;
vec.start.y = 0.4; vec.end.y = 1.6; vec.start.y = 0.4; vec.end.y = 1.6;
vec.print(); vec.print();

Object
Method name
instance

• Observe how some functions are closely print print

associated with a particular class
vec1 vec2
• Methods: functions which are part of a class
- Implicitly pass the current instance offset offset

Vector vec; Vector vec1;

vec.start.x = 1.2; vec.end.x = 2.0; Vector vec2;
vec.start.y = 0.4; vec.end.y = 1.6; // initialize vec1 and vec2
vec.print(); vec1.print();
vec.offset(1.0, 1.5);

Arguments • Analogy͗ Methods are “buttons” on each box

can be passed
to methods
(instance), which do things when pressed

11
 11/1/2014

print print print print

vec1 vec2 vec1 vec2

offset offset offset offset

Vector vec1; Vector vec1;

Vector vec2; Vector vec2;
// initialize vec1 and vec2 // initialize vec1 and vec2
vec1.print(); vec1.print();

Which box’s
button was Which button
pressed? was pressed?

class Vector { class Vector {

public: public:
Point start; Point start;
Point end; Point end;

void offset(double offsetX, double offsetY) { void offset(double offsetX, double offsetY) {
start.x += offsetX; start.x += offsetX;
end.x += offsetX; end.x += offsetX;
start.y += offsetY; methods start.y += offsetY; Fields can be accessed in a method
end.y += offsetY; end.y += offsetY;
} }
void print() { void print() {
cout << "(" << start.x << "," << start.y << ") -> (" << end.x << cout << "(" << start.x << "," << start.y << ") -> (" << end.x <<
"," << end.y << ")" << endl; "," << end.y << ")" << endl;
} }
}; };

12
 11/1/2014

class Vector {
public:
Point start, end; Implementing Methods Separately
void offset(double offsetX, double offsetY) { • Recall that function prototypes allowed us to
start.offset(offsetX, offsetY);
end.offset(offsetX, offsetY);
declare that functions will be implemented later
methods of fields can be called
} • This can be done analogously for class methods
void print() {
start.print(); // vector.h - header file
cout << " -> "; class Point {
end.print(); public:
cout << endl; double x, y;
} void offset(double offsetX, double offsetY);
}; void print();
class Point {
public: };
double x, y;
void offset(double offsetX, double offsetY) { class Vector {
x += offsetX; y += offsetY; public:
} Point start, end;
void print() { void offset(double offsetX, double offsetY);
void print();
cout << "(" << x << "," << y << ")";
} };
};

#include "vector.h"
// vector.cpp - method implementation
void Point::offset(double offsetX, double offsetY) {
• Manually initializing your fields can get tedious
}
x += offsetX; y += offsetY; • Can we initialize them when we create an
void Point::print() { instance?
cout << "(" << x << "," << y << ")";
}
void Vector::offset(double offsetX, double offsetY) {
start.offset(offsetX, offsetY);
end.offset(offsetX, offsetY); Vector vec;
Point p;
} vec.start.x = 0.0; p.x = 0.0;
void Vector::print() { ͗͗ indicates which class’ method is being
vec.start.y = 0.0; p.y = 0.0;
start.print(); implemented
cout << " -> "; vec.end.x = 0.0;
end.print(); vec.end.y = 0.0;
cout << endl;
}

13
 11/1/2014

Constructors Constructors
• Method that is called when an instance is created • Can accept parameters
class Point { class Point {
public: public:
double x, y; double x, y;
Point() { Point(double nx, double ny) {
x = 0.0; y = 0.0; cout << "Point instance created" << endl; x = nx; y = ny; cout << "2-parameter constructor" << endl;
} }
}; };

int main() { int main() {

Point p; // Point instance created Point p(2.0, 3.0); // 2-parameter constructor
// p.x is 0.0, p.y is 0.0 // p.x is 2.0, p.y is 3.0
} }

• Recall that assigning one class instance to another

Constructors copies all fields (default copy constructor)
• Can have multiple constructors
class Point { class Point {
public: public:
double x, y; double x, y;
Point() { Point() {
x = 0.0; y = 0.0; cout << "default constructor" << endl; x = 0.0; y = 0.0; cout << "default constructor" << endl;
} }
Point(double nx, double ny) { Point(double nx, double ny) {
x = nx; y = ny; cout << "2-parameter constructor" << endl; x = nx; y = ny; cout << "2-parameter constructor" << endl;
} }
}; };

int main() { int main() {

Point p; // default constructor Point q(1.0, 2.0); // 2-parameter constructor
// p.x is 0.0, p.y is 0.0) Point r = q; Invoking the copy constructor
Point q(2.0, 3.0); // 2-parameter constructor // r.x is 1.0, r.y is 2.0)
// q.x is 2.0, q.y is 3.0) }
}

14
 11/1/2014

• You can define your own copy constructor • Why make a copy constructor? Assigning all fields
(default copy constructor) may not be what you want
class Point {
public:
double x, y;
Point(double nx, double ny) {
x = nx; y = ny; cout << "2-parameter constructor" << endl;
}
Point(Point &o) { class MITStudent {
x = o.x; y = o.y; cout << "custom copy constructor" << endl; public:
} int studentID; int main() {
}; char *name; MITStudent student1;
MITStudent() { student1.studentID = 98;
int main() {
Point q(1.0, 2.0); // 2-parameter constructor studentID = 0; char n[] = "foo";
Point r = q; // custom copy constructor name = ""; student1.name = n;
// r.x is 1, r.y is 2 } MITStudent student2 = student1;
} }; student2.name[0] = 'b';
cout << student1.name; // boo
}
By changing student 2’s name, we
changed student 1’s name as well

• Why make a copy constructor? Assigning all fields

(default copy constructor) may not be what you want Access Modifiers
• Define where your fields/methods can be accessed
from
class MITStudent {
public:
int studentID; int main() {
char *name; MITStudent student1;
MITStudent() { student1.studentID = 98; class Point {
char n[] = "foo"; Access Modifier public:
studentID = 0;
double x, y;
name = ""; student1.name = n;
} MITStudent student2 = student1; Point(double nx, double ny) {
MITStudent(MITStudent &o) { student2.name[0] = 'b'; x = nx; y = ny;
studentID = o.studentID; cout << student1.name; // foo }
name = strdup(o.name); } };
} Changing student 2’s name doesn’t effect
}; student 1’s name

15
 11/1/2014

Access Modifiers Access Modifiers

• public: can be accessed from anywhere • private: can only be accessed within the class
class Point { class Point {
public: private:
double x, y; double x, y;

Point(double nx, double ny) { public:

x = nx; y = ny; Point(double nx, double ny) {
} x = nx; y = ny;
}; }
};
int main() {
Point p(2.0,3.0); int main() {
p.x = 5.0; // allowed Point p(2.0,3.0);
} p.x = 5.0; // not allowed
}

Access Modifiers Default Access Modifiers

• Use getters to allow read-only access to private fields • class: private by default
class Point {
private:
double x, y;
class Point {
public: double x, y;
Point(double nx, double ny) { };
x = nx; y = ny;
} Equivalent
double getX() { return x; } to
double getY() { return y; }
};
class Point {
int main() { private:
Point p(2.0,3.0); double x, y;
cout << p.getX() << endl; // allowed };
}

16
 11/1/2014

Structs Default Access Modifiers

• Structs are a carry-over from the C; in C++, • struct: public by default
classes are generally used • class: private by default
• In C++, they’re essentially the same as classes,
struct Point { class Point {
except structs’ default access modifier is public double x, y; double x, y;
}; };

Equivalent Equivalent
class Point { struct Point { to to
public:
double x; double x;
double y; double y; struct Point { class Point {
}; }; public: private:
double x, y; double x, y;
}; };

Disclaimer: Most of the contents

in this presentation have been
taken from MIT OpenCourseWare.

17