CS11 Advanced C++ FALL LECTURE 1

Transcription

1 CS11 Advanced C++ FALL LECTURE 1

2 Welcome! 2 Advanced C++ track is a deeper dive into C++ More advanced language features More use of the C++ standard library and the STL Development tools for larger projects Assumes general familiarity with Intro C++ material Track is being revised to include C++11 and C++14 features It may be a bit rough this term J

3 Lectures and Assignments 3 Aiming for 7-9 lectures Lectures will be posted on CS11 course website Aiming for 7-8 lab assignments Assignments will cover a variety of C++ topics A more involved project towards end of the term Both lectures and assignments are available at

4 Assignments 4 Advanced C++ track requires CS cluster account (as do all CS11 tracks by now) Assignments are submitted on csman Uses CS cluster for user authentication You can write your submissions on the CS cluster, but you aren t required to As long as we can compile and run your code with GNU g++ or LLVM clang, you re fine g++ -std=c clang -std=c (or use -std=c++11 if necessary)

5 C++ Operator Overloads 5 A 3D vector class: class Vector3D { float x, y, z;... }; Want to support addition and multiplication with our 3D vector class How to implement +=?

6 Operator Overloads (2) 6 Can implement as member operator overloads: class Vector3D { float x, y, z;... public: Vector3D & operator+=(const Vector3D &v); }; Called a member operator overload Vector3D v1, v2;... // Translated to v1.operator+=(v2); v1 += v2;

7 Operator Overloads (3) 7 Multiplication is a bit more complicated Vector3D v1, v2; float s;... v2 = v1 * s; // v1.operator*(s) v2 = s * v1; // s.operator*(v1)??? Can t implement this as a member operator overload float isn t a class!

8 Operator Overloads (4) 8 Instead, implement as a non-member operator overload Operator is outside of the Vector3D class Operator relies on Vector3D s public interface For multiplication simple arithmetic operator: class Vector3D { }; float x, y, z;... // Non-member operator overloads: const Vector3D operator*(const Vector3D &v, float s); const Vector3D operator*(float s, const Vector3D &v); Need a version for each call pattern you need

9 Operator Overloads (5) 9 Can easily leverage other operators to implement // Non-member operator overloads: const Vector3D operator*(const Vector3D &v, float s) { return Vector3D(v) *= s; } const Vector3D operator*(float s, const Vector3D &v) { return Vector3D(v) *= s; } Make a copy of v, then multiply by s and return it Assumes that Vector3D class has a *= member operator overload

10 Overload Guidelines 10 When to use member operator overloads, and when to use non-member overloads? These must be member functions: = () [] -> Compound assignment operators should be member-functions: += -= *= /= %= &= = They often can be implemented as non-member overloads, but it s usually slow and annoying

11 Overload Guidelines (2) 11 These cannot be member functions: >> << (at least, not when using them for stream-io) They require a stream on the LHS, and streams are part of the C++ Standard Library We can t change the stream code (We don t want to, anyway!)

12 Additional Guidelines (3) 12 If operator can be implemented using only the class public interface: Non-member overload is strongly recommended Most simple arithmetic operators fall in this category If operator supports mixed types (vector * scalar): Non-member overload is required If operator overload must be virtual (very rare): Member function is required (Only instance member functions may be virtual) If none of the above, make it a member function

13 Stream-Output Operators 13 C++ uses << for stream output, >> for stream input string name; cout << "What is your name? "; cin >> name; cout << "Hello, " << name << endl; Stream output operator: ostream & operator<<(ostream &os, const T &value); LHS is an output stream, RHS is value to output Return the passed-in ostream, to allow operator chaining

14 Example Stream-Output 14 Operator Implementation Simple implementation for our 3D vectors: ostream & operator<<(ostream &os, const Vector3D &v) { os << "(" << v[0] << ", " << v[1] << ", " << v[2] << ")"; return os; } Implement with simpler operations to make this easy Usually don t include an endl The caller should get to choose whether or not endl is added

15 Stream-Output Operator 15 Guidelines Simple implementation for our 3D vectors: ostream & operator<<(ostream &os, const Vector3D &v) { os << "(" << v[0] << ", " << v[1] << ", " << v[2] << ")"; return os; } Generally want to choose a clean, simple format Stream input should consume the same format Will cover stream input in a future lecture

16 Class Hierarchies and 16 Stream Output Implementing stream-output for class hierarchies can be a pain Shape A naïve approach: One operator<< implementation for every class in the hierarchy One major issue: Line Circle Rectangle Triangle When new classes are added in future, need to add another operator<< implementation Easy to leave out one of the classes by accident!

17 Class Hierarchies and 17 Stream Output (2) What about collections of pointers to these objects? Example: A vector of different shapes, stored as pointers vector<shape *> shapes; vector<shape *>::iterator iter; iter = shapes.begin(); while (iter!= shapes.end()) { cout << **iter << end; iter++; } What will this print? Shape Line Circle Rectangle Triangle

18 Class Hierarchies and 18 Stream Output (3) Recall: stream-output operator cannot be implemented as a member function std::ostream on LHS of operator, and we can t change ostream implementation Stream-output operator implementation cannot be virtual Compiler will use static type to choose << impl. while (iter!= shapes.end()) { } cout << **iter << end; iter++; This will always use the Shape version of operator<<

19 Class Hierarchies and 19 Stream Output (4) Need to leverage virtual functions for this problem Make a virtual Shape::print(ostream &) function Create one stream-output operator, for Shape ostream & operator<<(ostream &os, } s.print(os); return os; const Shape &s) { Every subclass provides its own version of print() Base class can force subclasses to implement print() themselves, by declaring it pure-virtual

20 Increment/Decrement 20 Operators C and C++ include increment (++) and decrement (--) operators int i = 5; int j = i++; i = 6, j = 5 int k = ++i; // post-increment // pre-increment i = 7, k = 7 Can overload these operators as well e.g. for user-defined numeric types, iterator implementations, etc.

21 Overloading 21 Increment/Decrement Need to distinguish between pre-increment and post-increment in function signature! Pre-increment takes no argument: T& T::operator++(); Returns a reference to variable after it has been incremented Post-increment takes a dummy int argument: const T T::operator++(int); Argument-value is meaningless! Don t use it! Returns a copy of the value before incrementing Decrement overloads follow same pattern

22 Overloading 22 Increment/Decrement (2) Usually implement post-increment in terms of preincrement const T T::operator++(int) { } const T old(*this); ++(*this); return old; // reuse! Could also specify full name of operator: this->operator++();

23 Post-increment and const 23 Why does post-increment return a const value? To prevent operator chaining! Example: A BigInt class that can represent arbitrarily large integers Defines prefix/postfix ++ and -- operators Postfix operators don t return const objects What is value of n after this code? BigInt n(3); // Initialize n = 3 n++++;

24 Post-Increment and const 24 (2) What is value of n after this code? BigInt n(3); // Initialize n = 3 n++++; What does the compiler see? n.operator++(0).operator++(0); (assume compiler passes 0 for dummy value) First operator++(int) returns a temporary object Second operator++(int) is called on that temporary object! This temporary object goes away at end of statement n only becomes 4, not 5!

25 Post-Increment and const 25 (3) If post-increment operator returns a const object, this code becomes invalid: n.operator++(0).operator++(0); Compiler won t allow a const object to be mutated The temporary object returned by first ++ call will be const

26 Casting Between Types 26 Classes can define type-conversion operators class A {... }; class B { };... // Convert from type B to type A operator A() { return A(...); } The compiler can use operator A() to convert a value of type B to a value of type A Can specify conversion operators for any type, including primitives or classes This is an implicit conversion operator: the compiler can use it without program explicitly invoking it

27 Implicit Conversions 27 Our example, revised: class A {... }; ostream & operator<<(ostream &os, const A &a); class B { };... operator A() { return A(...); } This compiles, even though B has no << operator!!! B b(...); cout << b << endl; b is implicitly converted into type A, then A s streamoutput operator is invoked

28 Explicit Conversions 28 Type conversions can be marked as explicit: class A {... }; ostream & operator<<(ostream &os, const A &a); class B { };... explicit operator A() { return A(...); } Now, compiler cannot use the conversion from B to A unless the code explicitly requests it B b(...); cout << b << endl; // Compile error! cout << (A) b << endl; // Explicit cast, works

29 Implicit Conversions and 29 Constructors Single-argument constructors also define implicit conversions class A {... }; class B { }; // Also allows conversion from A to B B(const A &a) {... } Compiler will use B s constructor to implicitly convert from A to B when necessary Again, use explicit to prevent compiler from performing implicit conversions from A to B explicit B(const A &a) {... }

30 This Week s Assignment 30 Implement a Rational class for representing and manipulating rational numbers Practice the operator overload guidelines Practice code-reuse when implementing operators Use assertions, const, write comments, etc. A test suite will be provided to verify your work