Best practices working with pointers in C++ functions with structs - c++

Question

I'm starting with C++ programming and I believe I have got a grasp about pointers. However I'm trying to understand the best practices for pointers and functions while using struts.
Toy example code
I have made below Toy example code to exemplify two ways to perform same thing:
#include <stdio.h>
struct rectangle {
int width;
int length;
};
void printRect(rectangle rect) {
printf("Rectangle: width=%d, length=%d\n",rect.width, rect.length);
}
void doubleSizeRectangle_1(rectangle *rect) {
rect->width = rect->width*2;
rect->length = rect->length*2;
}
rectangle doubleSizeRectangle_2(rectangle rect) {
rectangle *r = &rect;
r->width = r->width*2;
r->length = r->length*2;
return *r;
}
rectangle doubleSizeRectangle_3(rectangle rect) {
rect.width = rect.width*2;
rect.length = rect.length*2;
return rect;
}
int main()
{
rectangle rect;
rect.width = 2;
rect.length = 5;
rectangle *rect_pointer = new rectangle;
rect_pointer = &rect;
printRect(rect);
printRect(*rect_pointer);
printf("Applying functions:\n");
doubleSizeRectangle_1(rect_pointer);
printRect(rect);
rect = doubleSizeRectangle_2(*rect_pointer);
printRect(rect);
rect = doubleSizeRectangle_3(*rect_pointer);
printRect(rect);
}
That code returns following output:
Rectangle: width=2, length=5
Rectangle: width=2, length=5
Applying functions:
Rectangle: width=4, length=10
Rectangle: width=8, length=20
Rectangle: width=16, length=40
The first two prints are just to check about pointers usage.
The remaining prints are to check the three functions doubleSizeRectangle_1, doubleSizeRectangle_2 and doubleSizeRectangle_3 that perform same actions in different ways. The first one returns void and uses a pointer as input, whereas the second and third one have a variable as input and return a rectangle struct. Third option seems better than second, but would like to confirm. I'm not sure about the first one compared to the rest.
Question
Which option would be better in terms of best practice and why? Is there any of these options better in terms of avoiding memory leaks? May there be any other ways using pointers, and would those be even better than those I posted?

Answer 1

"best" is rather subjective, but using something complicated when there is no need to is not "best" in any sense.
Don't use new. Don't use pointers when there is no need to. Prefer references over pointers when nullptr is not a valid paramter (it isn't in your case). Use const references to avoid copies:
#include <stdio.h>
struct rectangle {
int width;
int lenght;
};
void printRect(const rectangle& rect) {
printf("Rectangle: width=%d, lenght=%d\n",rect.width, rect.lenght);
}
void doubleSizeRectangle_3(rectangle& rect) {
rect.width = rect.width*2;
rect.lenght = rect.lenght*2;
}
int main()
{
rectangle rect;
rect.width = 2;
rect.lenght = 5;
doubleSizeRectangle_3(rect);
printRect(rect);
}
Your function passed a pointer and returned the modified parameter. You do not need both. I changed it to return nothing and take the paramter by reference, because passing a nullptr does not make sense here.
You should also use a constructor to initialize the structs members, and prefer the type safe C++-IO (std::cout) over the non-typesafe C-IO.
For further reading: Why should C++ programmers minimize use of 'new'?

Answer 2

I suggest you to avoid doing like this:
rectangle doubleSizeRectangle_2(rectangle rect) {
rectangle *r = ▭
r->width = r->width*2;
r->lenght = r->lenght*2;
return *r;
}
you don't need to access that parameter using a pointer inside the method, you could simply access to object, because it's a copy.
As best practice, in order to minimize the risk of memory leak, the suggestion is to use smart pointers like this:
std::unique_ptr<rectangle> smartptrToRectangle(std::make_unique<rectangle>());
a smart pointer is a class that implements the RAII idiom:
RAII explanation
a smart pointer does destroy the element for you as soon as it go out of scope.

Answer 3

I would not use pointers for a function that edits a rectangle struct at all:
void doubleSizeRectangle(rectangle& rect)
{
rect.width = rect.width*2;
rect.lenght = rect.lenght*2;
}
The main difference between passing a pointer and a reference is just that a pointer can be unassigned while a reference always references a rectangle struct.
Your doubleSizeRectangle_1 essentially does the same thing. You should consider checking if the pointer is assigned if you want to stick to using pointers.
doubleSizeRectangle_2 makes no sense. You are passing your struct by value which means your function receives a copy of it. You then create a pointer to this object, manipulate it through that pointer to return it as a value again. The use of the pointer is useless there.
doubleSizeRectangle_3 is just doubleSizeRectangle_2 without the weird pointer. I wouldn't use this, it does at least one copy (when passing to the function) and one move operation (returning the struct from the function) that isn't nessecary for a function that just want's to edit the struct. Stick to my suggestion or your doubleSizeRectangle_1.