CSE 333 24sp Exercise 10

Due: Friday, April 26, 2024 by 11:00 am; No late exercises accepted.
Goals: Use C++ dynamic memory management operations new and delete, and use friend functions.

Description: In this exercise, you will modify the Vector type from the previous exercise (consider using our sample solution!). You will remove some of its simpler methods, switch out the underlying representation, and change how its overloaded operators are defined.

• In file Vector.h declare a class Vector with the following properties:
  • The representation of a Vector should be an array containing three doubles giving the magnitudes in the x, y, and z directions. The array should be dynamically allocated on the heap when a Vector is created, and deallocated when the Vector no longer exists.
  • (requirements are unchanged) There should be a default (0-argument) constructor that initializes a Vector to (0,0,0), a constructor with 3 doubles as parameters giving initial values for the x, y, and z magnitudes, and a copy constructor.
  • (requirements are unchanged) There should be a destructor that does whatever work is needed when a Vector object is deleted. If no work is needed, the body of the destructor can be empty.
  • The accessor functions get_x(), get_y(), and get_z() are no longer necessary.
  • (requirements are unchanged) The class should define assignment for Vectors (u=v).
  • (requirements are unchanged) The class should define updating assignment for Vectors (u+=v and u-=v) that perform element-by-element addition or subtraction of the vector components.
  • (requirements are unchanged) Operators + and - should be overloaded so that u+v and u-v return new Vectors that are the sum and difference of Vectors u and v, respectively.
  • (requirements are unchanged) Operator * should compute the inner product (dot product) of two Vectors. If v1=(a,b,c) and v2=(d,e,f), then v1*v2 should return the scalar value a*d+b*e+c*f as a double.
  • (requirements are unchanged) Operator * should be overloaded so that if v is the Vector (a,b,c) and k is a double, then v*k and k*v should return new Vectors containing the components of v multiplied by k (i.e., (a*k,b*k,c*k)).
  • (requirements are unchanged) The class should define stream output so that s<<v will write Vector v to stream s as (a,b,c), i.e., a left parentheses followed by the x, y, and z components of v separated by commas only, and a right parentheses. There should be no added spaces in the output.
  • (requirements are unchanged) The Vector class and associated functions should be placed in a namespace vector333.
  
  Note that several of these functions are required to "return new Vectors". This means actual Vector values, not pointers or references to Vectors that have been allocated elsewhere.

• In file Vector.cc implement the class as described above.
• In file ex10.cc write a main program that demonstrates that your Vector class works properly. The output format is up to you, but it should be labeled neatly and should be concise so it can be read with pleasure, not pain.
  
  It should show the operands and results of Vector operations, such as (1,-2,3)+(1,1,1)=(2,-1,4) so the reader can verify that the Vector operations work properly. Feel free to write using namespace vector333; in your test program so you don't need to type vector333:: repeatedly.
• Create a suitable Makefile. The command make should build an executable program ex10, recompiling individual files only when needed. The command make clean should remove the ex10 executable file, all .o files, and any editor or other backup files whose names end in ~.

Hints and tips:

• Some of the functions we need to implement, such as vector multiplication and stream output, need access to the instance variables of a vector even though no access functions like get_x() are included in the class this time. Instead, declare them as friend functions. For example, inside class Vector:

    // dot-product: if a is (a,b,c) and b is (x,y,z),
    // return ax+by+cz
    friend double operator*(const Vector &a, const Vector &b);
  

  Then, declare and implement the actual overloaded operator* function in the same namespace as the class; this will allow it to access private details of its Vector parameters.
• You may find it helpful to start with your code or the sample solution from the previous exercise (ex9) and modify it as needed to use the new array representation for the Vector data and make other necessary changes.

  ---

  As usual, your code must:

  • Compile without errors or warnings on CSE Linux machines (lab workstations, attu, or CSE home VM) with g++ -Wall -g -std=c++17 -o ex10 ex10.cc -- but don't forget to submit a Makefile.
  • Have no crashes, memory leaks, or memory errors on CSE linux machines
  • Have a Makefile, as described above, that compiles the code with the g++ options -Wall -g -std=c++17
  • Follow the quality guidelines we covered in class, including naming conventions for classes, methods, and instance variables; proper use of const; and appropriate comments. If in doubt, follow the Google C++ style guide; furthermore, cpplint may be helpful in flagging potential style problems. (You can ignore cpplint complaints about using namespace directives)
  • Be robust: you should think about handling bogus input from the user (if any), and you should handle hard-to-handle cases (if there are any) gracefully.
  • Have a comment at the top of each source file with your name, and CSE or UW email address.

  You should submit your exercise to the course Gradescope.