Does it cost to convert pointer to value in c++? - c++

Question

I am learning c++.
I learned when I should use 'pass by pointer' or 'pass by const reference' at google style guide.
It says
(1) if any members changes in a function, the value should be passed by pointer.
(2) if any members does not changed in a function, the value should be passed by const reference.
I wonder that when I have a pointer of a instance and any members will not change in a new function whether I need to make the function with pass by const reference to keep google style guide or not. If so, I need to convert the pointer to real value by '*pointer'. I am caring of the cost of conversion from pointer to real value but honestly I don't know whether it has cost or not. Please tell me how to do it in this situation.
This situation happens when I use visitor pattern. I need to use 'this' pointer but the members does not change in a function. I don't know whether there are any benefit or cost to keep google style guide in this situation.
In case, I copy sample code below. It is a part of visitor pattern. And it has two functions made with pass by pointer and pass by const reference.
#include <iostream>
class ClassA;
class VisitorInterface {
public:
virtual ~VisitorInterface() = default;
virtual void operator() (ClassA* obj) const = 0;
virtual void operator() (const ClassA& obj) const = 0;
};
class VisitorsHostInterface { // = visitor's host
public:
virtual ~VisitorsHostInterface() = default;
virtual void accept(VisitorInterface* v) = 0;
virtual void accept(const VisitorInterface& v) = 0;
};
class VisitorsHost : public VisitorsHostInterface {
public:
virtual ~VisitorsHost();
void accept(VisitorInterface* v) override {};
void accept(const VisitorInterface& v) override {};
};
class ClassA : public VisitorsHostInterface {
public:
void print() const { std::cout << "ClassA value_ = " << value_ << std::endl; }
void accept(VisitorInterface* v) override {
(*v)(this);
};
void accept(const VisitorInterface& v) override {
v(*this);
};
private:
int value_=11;
};
class Visitor : public VisitorInterface {
public:
virtual ~Visitor() = default;
void operator() (ClassA* obj) const override {
if (obj) {
obj->print();
}
}
void operator() (const ClassA& obj) const override {
obj.print();
}
};

Answer 1

In your case, no
You have two signatures
void accept(VisitorInterface* v) override {};
void accept(const VisitorInterface& v) override {};
They both expect a reference (or pointer and reference if you want to be exact), so you are not actually converting this to an object and in both cases you will just pass the address of this to each of the accept functions
However if you had
void accept(const VisitorInterface v) override {};
You could have invoked a copy-constructor which can be expensive, depending on what it does.

Answer 2

First, for the question you are asking, these is no difference between passing in *this and this from a performance standpoint when you have Thing * and const Thing & as the alternative overloads to select between.
But, your code has other confusions and problems. You have several different dimensions of visitation going on here, and I think you're confusing to orthogonal cases. Here are the cases as I see them:
You have a visitor that will be unchanged as it visits and the thing being visited will also not be changed.
You have a visitor that will be changed as it visits and the thing being visited will not be changed.
You have a visitor that will be unchanged as it visits and the thing being visited will be changed.
You have a visitor that will be changed as it visits and the thing being visited will also be changed.
I think you are confusing the cases of the thing being visited being changed, and the visitor changing as it visits things. If you weren't, you'd have four different accept methods all over the place instead of two, or the accept methods in the VisitorHostInterface and the VisitorInterface would have their const qualifiers in different spots.