Homework 8 -- More on Pointers, Dynamic Memory, Operator Overloading

Section 1.8 Homework 8 -- More on Pointers, Dynamic Memory, Operator Overloading

Exercises Exercises

1.

A primary purpose of the destructor is to ...

🔗

release an object’s dynamic (heap)memory allocation when the object is no longer in use
release an object’s static (stack)memory allocation when the object is no longer in use

🔗

2.

The name of the destructor always begins with the special character ____ .

🔗

3.

Which of the following is TRUE of the class destructor?

🔗

The destructor has no parameters and no return value.
The destructor has no parameters, but it does have a return value.
The destructor has no return value, but it does have parameters.
The destructor has both a return value and parameters.

🔗

4.

Which of the following is a true statement about when the destructor of a class is activated?

🔗

If an object of class Foo was created in dynamic memory with the `new` keyword, then the Foo class destructor will be activated when `delete` is called on a pointer holding the address of the object.
If an object of class Foo was created and assigned to a variable in the stack, the Foo class destructor will be activated when the variable goes out of scope.
If an object of class Foo was passed by value to a function, then the Foo class destructor will be activated to delete the local copy of the object when the function ends.
The class destructor is only activated when called explicitly, such as: ~Foo(my_foo)

🔗

5.

Dynamic data structures, created in the heap using pointers, let us set the SIZE of the data structure ...

🔗

at runtime
at compilation time
during pre-processing

🔗

6.

We are implementing an assignment operator with the following prototype:

🔗

Image& operator=(const Image& source);

🔗

It’s important to check for self-assignment when implementing the assignment operator for a class. Which of the following is a correct check for possible self-assignment?

🔗

if (this == &source) { return; }
if (this == source) { return; }
if (*this == &source) { return; }
if (*this == source) { return; }

🔗

7.

True, or false? The automatic assignment operator fails for any class that uses dynamic memory.

🔗

True
False

🔗

8.

Suppose im1 is an existing Image object.

🔗

When the following line of code is executed, which function will be activated?

🔗

Image im2(im1);

🔗

The Image class copy constructor.
The Image class default constructor.
The Image class assignment operator (operator=).

🔗

9.

Consider an Image class like the one in our labs. Suppose the Image object `im_2` is already initialized. Consider the following line of code:

🔗

Image im_1(im_2.getWidth(), im_2.getHeight());

🔗

When this code executes, does it activate the copy constructor?

🔗

10.

Refer to the Image class. Suppose the Image object `im_2` is already initialized. Consider the following line of code:

🔗

Image im_1 = im_2;

🔗

When this code executes, does it activate the copy constructor?

🔗

11.

Refer to the Image class, as in Lab 3. Suppose the Image objects `im_1` and `im_2` are already initialized. Consider the following line of code:

🔗

im_1 = im_2;

🔗

When this code executes, does it activate the copy constructor?

🔗

12.

Suppose the function getImage() has the following prototype:

🔗

Image getImage();

🔗

When the return statement of getImage() is executed, does it activate the Image class copy constructor?

🔗

13.

🔗

14.

Assume a Pixel class with member variables named blue, red and green

🔗

Implement a member function called is_white for the Pixel class. It takes no arguments.

🔗

The function is_white returns true if this is a white pixel (all three color values are 255); otherwise, is_white returns false.

🔗

#include <sstream>

// FILE: Pixel_inlined.cpp
// 2-14-18
// Pixel code for coderunner questions
#include <iostream>
#include <string>
#include <sstream>
using namespace std;

// Pixel class definition
class Pixel
{
   public:
    // NEW FUNCTION FOR THIS PROBLEM! 
    // return true if this is a white pixel, else, return false
    bool is_white();
    
    // CONSTRUTOR
    Pixel( int r=0, int g=0, int b=0 )
    { red = r; green = g; blue = b; }

// MODIFICATION MEMBER FUNCTIONS
    void set( int r, int g, int b )
    { red = r; green = g; blue = b; }

void setRed( int r )
    { red = r; }

void setGreen( int g )
    { green = g; }

void setBlue( int b )
    { blue = b; }

// ACCESSOR MEMBER FUNCTIONS
    int getRed( ) const
    { return red; }

int getGreen( ) const
    { return green; }

int getBlue( ) const
    { return blue; }

// FRIEND FUNCTIONS
    friend std::ostream& operator<< (std::ostream& out, const Pixel& pix);
    friend std::istream& operator>> (std::istream& in, Pixel& pix);

private:
    // INSTANCE VARIABLES
    int red;   // red level for RGB color model, 0 <= red <=255
    int green;   // green level for RGB color model, 0 <= red <=255
    int blue;   // blue level for RGB color model, 0 <= red <=255
};  // end class definition

// OPERATOR OVERLOADS (Friends)
std::ostream& operator<< (std::ostream& out, const Pixel& pix)
{
    out << pix.getRed() << " " << pix.getGreen() << " " << pix.getBlue();

return out;
}

std::istream& operator>> (std::istream& in, Pixel& pix)
{
   int r, g, b;
   in >> r >> g >> b;
   pix.setRed(r);
   pix.setGreen(g);
   pix.setBlue(b);

return in;
}

// OTHER NON-MEMBER FUNCTIONS 
bool operator== (const Pixel& pix1, const Pixel& pix2)
{
    return (pix1.getRed() == pix2.getRed()) &&
    (pix1.getGreen() == pix2.getGreen()) &&
    (pix1.getBlue() == pix2.getBlue());
}

bool operator!= (const Pixel& pix1, const Pixel& pix2)
{
   return !(pix1 == pix2);
}

^^^^
bool Pixel::is_white()
{
    
}
====
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "doctest.h"

TEST_CASE( "test1" ) {
    std::stringstream cout;
    Pixel pix;
    if (pix.is_white()) { cout << "this is a white pixel!" << endl; }
    else { cout << "this is NOT a white pixel." << endl; }
    
    
    ;
    std::string answer = "this is NOT a white pixel.\n";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test2" ) {
    std::stringstream cout;
    Pixel pix(253, 254, 255);
    if (pix.is_white()) { cout << "this is a white pixel!" << endl; }
    else { cout << "this is NOT a white pixel." << endl; }
    
    ;
    std::string answer = "this is NOT a white pixel.\n";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test3" ) {
    std::stringstream cout;
    Pixel pix(255, 255, 255);
    if (pix.is_white()) { cout << "this is a white pixel!" << endl; }
    else { cout << "this is NOT a white pixel." << endl; }
    
    ;
    std::string answer = "this is a white pixel!\n\n";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test4" ) {
    std::stringstream cout;
    Pixel pix(0, 255, 255);
    if (pix.is_white()) { cout << "this is a white pixel!" << endl; }
    else { cout << "this is NOT a white pixel." << endl; }
    
    ;
    std::string answer = "this is NOT a white pixel.";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test5" ) {
    std::stringstream cout;
    Pixel pix(255, 255, 254);
    if (pix.is_white()) { cout << "this is a white pixel!" << endl; }
    else { cout << "this is NOT a white pixel." << endl; }
    
    ;
    std::string answer = "this is NOT a white pixel.";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test6" ) {
    std::stringstream cout;
    Pixel pix(254, 255, 255);
    if (pix.is_white()) { cout << "nope" << endl; }
    else { cout << "OK" << endl; }
    
    ;
    std::string answer = "OK";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test7" ) {
    std::stringstream cout;
    Pixel pix(255, 255, 255);
    if (pix.is_white()) { cout << "Yes!" << endl; }
    else { cout << "No" << endl; }
    
    ;
    std::string answer = "Yes!";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test8" ) {
    std::stringstream cout;
    Pixel pix(255, 253, 255);
    if (pix.is_white()) { cout << "Yes!" << endl; }
    else { cout << "No" << endl; }
    
    ;
    std::string answer = "No";
    CHECK( cout.str() == answer );
}

🔗

15.

Assume a point class with member variables x, y, member functions get_x() and get_y(), and a constructorpoint(x,y).

🔗

Below is the documentation for the addition (+) operator for the point class.

🔗

/*
 * addition operator (+)
 *
 * The x value for the result is the sum of the x values for the two points being added, and 
 * the y value for the result is the sum of the y values for the two points being added.
 * returns a new point that is the sum of two other points
 *
 * Example:  if point1 is (4, -2) and point2 is (3, 1), then 
 *           point1 + point2 will return the point (7, -1)
 */

Write the code to turn the given stub definition for the function into a complete implementation. Note that you will need to use get_x and get_y to reach the values, as the operator is not defined as a friend of the class.

🔗

#include <sstream>

#include <iostream>
#include <string>
#include <sstream>
using namespace std;

// class definition
class point
{
public:
    // CONSTRUCTOR
    point(double initial_x = 0.0, double initial_y = 0.0);
    
    // ACCESSORS
    double get_x( ) const { return x; }
    double get_y( ) const { return y; }
    
    // MODIFIERS
    void shift(double x_amount, double y_amount);
    void rotate90( );
    
    // FRIENDS
    friend std::istream& operator >>(std::istream& ins, point& target);

private:
        double x; // x coordinate of this point
        double y; // y coordinate of this point
};

// implementation
point::point(double initial_x, double initial_y)
{
	x = initial_x;   // Constructor sets point to a given position
	y = initial_y;
}

void point::shift(double x_amount, double y_amount)
{
	x += x_amount;
	y += y_amount;   
}

void point::rotate90( )
{
	double new_x;
	double new_y;

new_x = y;  // For a 90 degree clockwise rotation the new y is -1
	new_y = -x; // times original x, and the new x is the original y
	x = new_x;
	y = new_y;   
}

ostream& operator<<(ostream &out, const point &pt)
{  
   out << "(" << pt.get_x() << ", " << pt.get_y() << ")";
   return out;
}

^^^^
point operator+(const point &pt1, const point &pt2)
{  
   return pt1;  // CHANGE THIS LINE (it's a stub)
}
====
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "doctest.h"

TEST_CASE( "test1" ) {
    std::stringstream cout;
    point pt1(-1.5, 3.75);
    point pt2(0.5, 0.5);
    cout << pt1 + pt2;
    
    ;
    std::string answer = "(-1, 4.25)";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test2" ) {
    std::stringstream cout;
    point pt1(10, 3);
    point pt2(-1, -1);
    cout << pt1 + pt2;
    
    ;
    std::string answer = "(9, 2)";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test3" ) {
    std::stringstream cout;
    point pt1(80, -55.2);
    point pt2(-50, -50);
    cout << pt1 + pt2;
    
    ;
    std::string answer = "(30, -105.2)";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test4" ) {
    std::stringstream cout;
    point pt1(-12.8, -18.5);
    point pt2(3.5, 6.5);
    cout << pt1 + pt2;
    
    ;
    std::string answer = "(-9.3, -12)";
    CHECK( cout.str() == answer );
}

🔗

16.

Assume a point class with member variables x, y, member functions get_x() and get_y(), and a constructorpoint(x,y).

🔗

Below is the documentation for the multiplication (*) operator for the point class.

🔗

/*
 * multiplication operator (*)
 *
 * Calculates the dot product of two points by adding the product of the x's
 * and the product of the y's.
 * returns the dot product of two points
 *
 * Example:  if point1 is (4, -2) and point2 is (3, 1), then 
 *           the dot product would be (4 * 3) + (-2 * 1), i.e., 10
 */

Write the code to turn the given stub definition for the function into a complete implementation. Note that this will not be a friend to the class, so you will need to use get_x and get_y to access the member variables values.

🔗

#include <sstream>

#include <iostream>
#include <string>
#include <sstream>
using namespace std;

private:
        double x; // x coordinate of this point
        double y; // y coordinate of this point
};

// implementation
point::point(double initial_x, double initial_y)
{
	x = initial_x;   // Constructor sets point to a given position
	y = initial_y;
}

void point::shift(double x_amount, double y_amount)
{
	x += x_amount;
	y += y_amount;   
}

void point::rotate90( )
{
	double new_x;
	double new_y;

new_x = y;  // For a 90 degree clockwise rotation the new y is -1
	new_y = -x; // times original x, and the new x is the original y
	x = new_x;
	y = new_y;   
}

ostream& operator<<(ostream &out, const point &pt)
{  
   out << "(" << pt.get_x() << ", " << pt.get_y() << ")";
   return out;
}

^^^^
double operator*(const point &pt1, const point &pt2)
{  
   return 0;
}
====
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "doctest.h"

TEST_CASE( "test1" ) {
    std::stringstream cout;
    point pt1(-1.5, 3.75);
    point pt2(0.5, 0.5);
    cout << pt1 * pt2;
    
    ;
    std::string answer = "1.125";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test2" ) {
    std::stringstream cout;
    point pt1(10, 3);
    point pt2(-1, -1);
    cout << pt1 * pt2;
    
    ;
    std::string answer = "-13";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test3" ) {
    std::stringstream cout;
    point pt1(80, -55.2);
    point pt2(-50, -50);
    cout << pt1 * pt2;
    
    ;
    std::string answer = "-1240";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test4" ) {
    std::stringstream cout;
    point pt1(-12, -18.5);
    point pt2(3.5, 6.5);
    cout << pt1 * pt2;
    
    ;
    std::string answer = "-162.25";
    CHECK( cout.str() == answer );
}

🔗

17.

Assume a point class with member variables x, y, member functions get_x() and get_y(), and a constructorpoint(x,y).

🔗

Below is the documentation for the equivalence (==) operator for the point class.

🔗

/*
 * equivalence (==)
 *
 * Two points are equivalent if they have the same x value and the same y value.
 * returns true if point1 and point2 are equivalent; otherwise, returns false
 */

Write the code to turn the given stub definition for the function into a complete implementation. Note that this will not be a friend to the class, so you will have to use get_x and get_y to access the variables.

🔗

#include <sstream>

#include <iostream>
#include <string>
#include <sstream>
using namespace std;

private:
        double x; // x coordinate of this point
        double y; // y coordinate of this point
};

// implementation
point::point(double initial_x, double initial_y)
{
	x = initial_x;   // Constructor sets point to a given position
	y = initial_y;
}

void point::shift(double x_amount, double y_amount)
{
	x += x_amount;
	y += y_amount;   
}

void point::rotate90( )
{
	double new_x;
	double new_y;

new_x = y;  // For a 90 degree clockwise rotation the new y is -1
	new_y = -x; // times original x, and the new x is the original y
	x = new_x;
	y = new_y;   
}

ostream& operator<<(ostream &out, const point &pt)
{  
   out << "(" << pt.get_x() << ", " << pt.get_y() << ")";
   return out;
}

^^^^
bool operator==(const point &pt1, const point &pt2)
{  
   return false;
}
====
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "doctest.h"

TEST_CASE( "test1" ) {
    std::stringstream cout;
    point pt1(-1.5, 3.75);
    point pt2(-1.5, 3.75);
    if (pt1 == pt2)
        cout << "equivalent";
    else
        cout << "not equivalent";
    
    ;
    std::string answer = "equivalent";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test2" ) {
    std::stringstream cout;
    point pt1(9, 2);
    point pt2(2, 9);
    if (pt1 == pt2)
        cout << "equivalent";
    else
        cout << "not equivalent";
    
    ;
    std::string answer = "not equivalent";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test3" ) {
    std::stringstream cout;
    point pt1(30, -105.2);
    point pt2(30, -105);
    if (pt1 == pt2)
        cout << "equivalent";
    else
        cout << "not equivalent";
    
    ;
    std::string answer = "not equivalent";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test4" ) {
    std::stringstream cout;
    point pt1(-9.3, -12);
    point pt2(9.3, 12);
    if (pt1 == pt2)
        cout << "equivalent";
    else
        cout << "not equivalent";
    
    ;
    std::string answer = "not equivalent";
    CHECK( cout.str() == answer );
}

🔗

18.

Assume a point class with member variables x, y, member functions get_x() and get_y(), and a constructorpoint(x,y).

🔗

Below is the documentation for an input stream operator (>>) function for the point class.

🔗

/*
 * input stream operator (>>)
 *
 *    - takes data from the input stream and assigns new values to the 
 *      instance variables of the point
 *    - returns the 'in' parameter to allow for chaining
 *
 * Note:  The input consists of the following: "(x, y)" where x and y
 *        are doubles.
 *
 * Example:  If the input stream 'in' holds the message
 *               "(-1.5, 3.75)"
 *           then 'in >> pt' will cause pt's data to become
 *           x: -1.5; y: 3.75
 *

Write the code to turn the given stub definition for the function into a complete implementation. This will be a friend to the class, so you can directly write into the x and y variables.

🔗

HINT: Be sure to consume all the input, "(x here..., y here...)", including the parentheses, and the comma. You can use the input stream function ignore to skip characters.

🔗

#include <sstream>

#include <iostream>
#include <string>
#include <sstream>
using namespace std;

private:
        double x; // x coordinate of this point
        double y; // y coordinate of this point
};

// implementation
point::point(double initial_x, double initial_y)
{
	x = initial_x;   // Constructor sets point to a given position
	y = initial_y;
}

void point::shift(double x_amount, double y_amount)
{
	x += x_amount;
	y += y_amount;   
}

void point::rotate90( )
{
	double new_x;
	double new_y;

new_x = y;  // For a 90 degree clockwise rotation the new y is -1
	new_y = -x; // times original x, and the new x is the original y
	x = new_x;
	y = new_y;   
}

ostream& operator<<(ostream &out, const point &pt)
{  
   out << "(" << pt.get_x() << ", " << pt.get_y() << ")";
   return out;
}

^^^^
istream& operator>>(istream &in, point &pt)
{  
    return in;
}
====
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "doctest.h"

TEST_CASE( "test1" ) {
    std::stringstream cout;
    stringstream message;
    message << "(-1.5, 3.75)";
    point pt(0, 0);
    message >> pt;
    cout << pt;
    
    ;
    std::string answer = "(-1.5, 3.75)";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test2" ) {
    std::stringstream cout;
    stringstream message;
    message << "(10, 3)";
    point pt(0, 0);
    message >> pt;
    cout << pt;
    
    ;
    std::string answer = "(10, 3)";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test3" ) {
    std::stringstream cout;
    stringstream message;
    message << "(80, -55.2)";
    point pt(0, 0);
    message >> pt;
    cout << pt;
    
    ;
    std::string answer = "(80, -55.2)";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test4" ) {
    std::stringstream cout;
    stringstream message;
    message << "(-12.8, -18.5)";
    point pt(0, 0);
    message >> pt;
    cout << pt;
    
    ;
    std::string answer = "(-12.8, -18.5)";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test5" ) {
    std::stringstream cout;
    stringstream message;
    message << "(-12.8, -18.5)" << "(1.1, 2.2)";
    point pt1(0, 0);
    message >> pt1 >> pt1;
    cout << pt1;
    
    ;
    std::string answer = "(1.1, 2.2)";
    CHECK( cout.str() == answer );
}

🔗

19.

Assume a point class with member variables x, y, member functions get_x() and get_y(), and a constructorpoint(x,y).

🔗

Below is the documentation for an output stream operator (<<) function for the point class.

🔗

/*
 * output stream operator (<<)
 *
 * output a point to a stream
 * returns the 'out' parameter to allow for chaining
 *
 * Note:  The output of a point looks like the following:
 *           "(x, y)"
 *        where x is the x-value and y is the y-value for the point.
 *
 * Example:  Calling the output stream operator on a point with 
 *           x = 4 and y = -2 would produce the following: (4, -2)
 */

Write the code to turn the given stub definition for the function into a complete implementation.

🔗

HINT: The output stream operator is NOT a friend of the class. Use the getters to access the values of member variables x and y.

🔗

#include <sstream>

#include <iostream>
#include <string>
#include <sstream>
using namespace std;

private:
        double x; // x coordinate of this point
        double y; // y coordinate of this point
};

// implementation
point::point(double initial_x, double initial_y)
{
	x = initial_x;   // Constructor sets point to a given position
	y = initial_y;
}

void point::shift(double x_amount, double y_amount)
{
	x += x_amount;
	y += y_amount;   
}

void point::rotate90( )
{
	double new_x;
	double new_y;

new_x = y;  // For a 90 degree clockwise rotation the new y is -1
	new_y = -x; // times original x, and the new x is the original y
	x = new_x;
	y = new_y;   
}

^^^^
ostream& operator<<(ostream &out, const point &pt)
{  
   out << "stream output not implemented";
   return out;
}
====
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "doctest.h"

TEST_CASE( "test1" ) {
    std::stringstream cout;
    point pt(-1.5, 3.75);
    cout << pt;
    
    ;
    std::string answer = "(-1.5, 3.75)";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test2" ) {
    std::stringstream cout;
    point pt(10, 3);
    cout << pt;
    
    ;
    std::string answer = "(10, 3)";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test3" ) {
    std::stringstream cout;
    point pt(80, -55.2);
    cout << pt;
    
    ;
    std::string answer = "(80, -55.2)";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test4" ) {
    std::stringstream cout;
    point pt(-12.8, -18.5);
    cout << pt;
    
    ;
    std::string answer = "(-12.8, -18.5)";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test5" ) {
    std::stringstream cout;
    point pt1(80, -55.2);
    point pt2(5.3, -5.3);
    cout << pt1 << " and " << pt2;
    
    ;
    std::string answer = "(80, -55.2) and (5.3, -5.3)";
    CHECK( cout.str() == answer );
}

🔗

You have attempted of activities on this page.

🔗

Prev Top Next