C ++成员函数需要指针，不好的做法是通过引用传递？

Question

If a C++ class member function requires a pointer to an object as an argument, is it considered bad practice to pass by reference?

The following code, for example, will work, however without the pass by reference it becomes a dangerous code, and will lead to catastrophic errors at runtime.

class ClassA
{
public:
    void SetPointer(const ClassB& classb) // Remove 1 ampersand and serious errors will occur
    {
        if(ptr_to_classb == nullptr) // Initialized to nullptr in constructor
            ptr_to_classb = &classb;
        else
            throw(...); // Throw some error
    }

private:
    ClassB* ptr_to_classb;
}

Consider if passing by value, and a copy of the argument was made, that this would be disastrous when dereferencing at a later time.

The alternative is this:

class ClassA
{
public:
    void SetPointer(const ClassB* const classb)
    {
        if(ptr_to_classb == nullptr) // Initialized to nullptr in constructor
            ptr_to_classb = (ClassB*)(classb);
        else
            throw(...); // Throw some error
    }

private:
    ClassB* ptr_to_classb;
}

I like consistency, to defaulted to the first type, however I suspect that the second form is considered to be better practice. Is this the case?

Answer 1

My view is that if passing a null argument to the method is a valid thing to do (ie the logic that the method executes would be valid with a null pointer), then use a pointer. If the argument should never be null then use a reference.

In your case this depends on whether it is valid for ClassA::ptr_to_classb to be null. Since you throw if ptr_to_classb is already set (meaning you don't ever want to change what it points to) you might even want to conside storing a reference instead and passing that in the constructor of ClassA, getting rid of ClassA::SetPointer.

There are some other opinions on reference vs pointer here as well .

Answer 2

Well, both approaches are correct and fine but in your case it will be probably better to go with pointers, since a reference variable can only be assigned a value at initialization unlike pointers. With the same pointer you could later pass a different class object.

Answer 3

Your method just sets a field of your object, so it seems you want to use the type of the field (which is pointer, not reference). You wrote

I like consistency, to defaulted to the first type

which, I guess, refers to the rule "use references when possible; use pointers oterwise". I think your case is an exception from this rule, because the declaration

void do_stuff(ClassA& object)

usually means "do stuff on the object, and forget about it", and your case is different.