CODEWITHSUNDEEP
c++classpointers
Reggie78
Reggie78

Reputation: 29

Changing what a pointer points to?

I am very new to programming, and am near the end of this program, but cannot quite finish the last detail, which I have been stuck on. I am attempting to switch what shape pointer *sp is pointing to, and it seems to me that what I am doing should work, since rectangle and circle both are shapes; however, when I compile, only the value of the color changes. The area of the circle prints instead of the area of the rectangle and the perimeter prints 0. Any help would be greatly appreciated!

#include <iostream>
#include <string>
using namespace std;
double const pi = 3.1519;
class shape {
    public:
        shape() {};
        shape(string);
        virtual double getCircumference() {
            return 0;
        };
        virtual double getPerimeter() {
            return 0;
        };
        virtual double getArea() {
            return 0;
        };
        string getColor();


    protected:
        string color;

};

string shape::getColor() {
    return color;
}

class circle : public shape {
public:

    circle(double r, string c) {

        radius = r;
        color = c;
    };
    double getArea();
    double getCircumference();


private:
    double radius;


};
double circle::getCircumference() {
    return pi * radius * 2;
}
double circle::getArea() {
    return pi * radius * radius;
}
class rectangle:public shape {

public:

    rectangle(double w, double l, string c) {
        width = w;
        length = l;
        color = c;
    };

    double getArea();
    double getPerimeter();

private:
    double length;
    double width;

};
double rectangle::getPerimeter() {
    return width * 2 + length * 2;
}
double rectangle::getArea() {
    return length * width;
}
void change(shape *sp, shape *sp1) {
    *sp = *sp1;
}
int main() {

    circle mary(3.2, "Green");
    shape *sp = new circle(4.5, "Yellow");

    cout << "Circle #1 is " << mary.getColor() << endl;
    cout << "Circle #1 has an area of " << mary.getArea() << endl;
    cout << "Circle #1 has a circumference of " << mary.getCircumference() << endl << endl;
    cout << "Circle #2 is " << sp->getColor() << endl;
    cout << "Circle #2 has an area of " << sp->getArea() << endl;
    cout << "Circle #2 has a circumference of " << sp->getCircumference() << endl << endl;

    shape *sp1 = new rectangle(1.0, 2.1, "Red");

    change(sp, sp1);

    cout << "Rectangle #1 is " << sp->getColor() << endl;
    cout << "Rectangle #1 has an area of " << sp->getArea() << endl;
    cout << "Rectangle #1 has a perimeter of " << sp->getPerimeter() <<endl<< endl;

}

Upvotes: 1

Views: 3467

Answers (3)

Seph
Seph

Reputation: 31

It’s important to keep in mind what is meant by various different ways of using pointers. In your program, sp refers to the pointer itself—that is, a memory location telling the computer where to find an object. The asterisk in *sp is a ‘dereference’ operator; it takes a pointer and gives you the thing that it is pointing to.

With this in mind, your line *sp = *sp1; is saying, ‘take the thing that sp is pointing to, and set it to be equal to the thing that sp1 is pointing to.’ In other words, you are changing the value of the object pointed to by sp, not the value of sp itself. To point sp at the object pointed to by sp1, you need sp = sp1; with no asterisks.

The other thing to bear in mind is that C++ by default passes function arguments by value: when the function is called, the arguments are copied, and the function operates on the copies. This means that the original arguments themselves cannot be changed by a function that works like this. Adding an ampersand to the argument declaration, like void change(shape *&sp, shape *sp1) causes the first argument to be passed by reference: the object operated on by the function is the same object that was passed in by the calling code. This allows the function to change objects passed as arguments, and for those changes to remain after the function has returned.

Sorry for the long answer: I could have given you a few lines that did what you wanted, but I thought you might appreciate an explanation of the reason why things work the way they do.

Upvotes: 2

Jack
Jack

Reputation: 133567

A pointer is passed by value even if it's a pointer.

This means that you are actually passing the address by value, so the argument is a copy of the original argument.

Think about

void sum(int a, int b, int result);
void foo() {
  int result;
  sum(5,10,result);
}

While you expect to be able to store the result into the variable passed to the sum argument you won't be able to do it since result is passed by value and hence copied. Every modification you do to result inside the method will be local to the method.

That's exactly the same thing, a pointer is nothing more than an address, if you pass it by value then a copy of the address is passed but every modification to the local variable is just local.

That's why you must use references if you want to be able to modify their values, exactly as every other variable, so you would have

void sum(int a, int b, int& result);
void change(shape*& shape1, shape*& shape2);

This, under the hood, will pass the address to the variable which stores the address (a sort of shape**) so the function is able to know where the original argument is located and modify it directly.

Upvotes: 1

yizzlez
yizzlez

Reputation: 8805

If you are trying to change the address of pointers, you must pass pointers by reference. Try this:

void change(shape *&sp, shape *&sp1)

Upvotes: 1

Related Questions