CSE 333 25sp Exercise 10

out: Monday, April 28, 2025
due: Wednesday, April 30, 2025 by 10:00 am, No late exercises accepted.

Goals: Create a modified version of the Vector type from the previous exercise using dynamic memory allocation and friend functions this time. Learn how to use C++ dynamic memory management operations new and delete.

Description: Create a C++ class Vector that implements 3-D vectors and has almost the same specification as the Vector class from the previous exercise, but this time does not include the get_x, get_y, and get_z accessor functions from before, and that uses a different representation for the data as described below.

• 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 deleted when the Vector no longer exists.
  • 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.
  • 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 class should define assignment for Vectors (u=v).
  • 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.
  • 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.
  • 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.
  • 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)).
  • The header 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.
  • 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 this class.

• 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: 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 inside the class that these external routines are 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);

The actual overloaded operator* function is then declared and implemented as a separate ordinary function in the same namespace as the class, but it can 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.

---

Your code must:

• compile without errors or warnings on CSE Linux machines (lab workstations, attu, or CSE home VM)
• 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 -std=c++17 -g .
• Follow the style 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, and cpplint may be helpful in flagging potential style problems. (You can ignore cpplint complaints about using namespace directives.)
• be pretty: the formatting, modularization, variable and function names, use of const and so on must make us smile rather than cry.
• 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 using the Gradescope dropbox linked on the course resources web page.