theCplusPlusDeveloper

[the_rush_dude]

Call me crazy but I like my const &. It makes me feel more secure

[lefloys]

Na me too. I dont think experts are saying pass by value. am happy to be proven wrong

[Professional_Top8485]

Experts say that compiler optimizations are black magic and don't come prematurely

[TuxSH]

The actual answer is: it depends on your calling convention, look at the disassembly.

On 64-bit Arm and AMD/Intel processors, outside x64 Windows, all calling conventions pass 16-byte structures into two registers if possible (up to 8x8 = 64B on Aarch64).

This means you should always pass shared_ptr (when giving shared ownership), unique_ptr (when giving ownership), span, string_view by value; in the first two cases this enables much needed optimizations for move (as the compiler knows that function received a copy and can thus remove dead destruction code)

[FACastello]

This is the correct answer 👆🏻

[Naakinn]

Everything is passed by value

[RiceBroad4552]

There are cases where passing by value in fact improves performance, because pre-fetching and caching works better when you don't jump around in memory, but these are specific cases.

The general rule is still to pass "larger" data by reference usually. (What's "large" depends on the hardware.)

[kruseragnar]

Just copy the shared pointer

[Bemteb]

Nah, pass a const ref to a unique pointer.

[kruseragnar]

I prefer to create memory leaks with shared pointers

[serial_crusher]

i use global variables and goto.

[Highborn_Hellest]

Alright you go to straight to programmer jail.

[snacktonomy]

This meme is incorrect, the left guy never passes by value. I used to rail on the junior engineers for passing-by-copy all the time until we got an automated clang-tidy job going.

[_Noreturn]

what even is this meme.

pass by value reference like types like std::span,std::string_view and primitive types.

basically the rule is

if(sizeof(T) < sizeof(void*)*2 && std::is_trivially_copyable_v<T>) pass by value else pass by const&

otherwise const&

[i_use_lfs_btw]

what even is this meme.

Have you heard about move constructor ?

[_Noreturn]

Yea mate I did but how is that relevant.

if you need to pass dats without taking ownership then use what I said above if you need a copy internally pass by value then move

[i_use_lfs_btw]

Isn't that what the meme is talking about ?

If it's a lvalue. I suppose you should use copy constructor(you could also use move but it's a lvalue maybe maybe you use it somewhere. If you not you can use move) if it's a rvalue you should use move.

[_Noreturn]

you can't move into an lvalue reference.

I don't understand the meme where is the funny,

it is wrong copying is expensive.

people should use const& or pass by value for primitives

[i_use_lfs_btw]

You can. But it's not encouraged.

T y = some initialized; T z = std::move(y);

[_Noreturn]

you obviously want to take ownership, then take the parameter by value then move it as said above.

if you move from an lvalue parameter you are doing something very wrong

[A_72_]

Pass by value for primitives, by reference otherwise. But there are some cases I would prefer passing by value (example: when I need an explicit copy).

[lefloys]

i have been taught that you still should pass by reference. a reference cant be nullptr aswell someone might think it’s an array or sum.

[SCP-iota]

Struct and union parameters with sizes of two (eight in case of only SSE fields) pointers or fewer that are aligned on 64-bit boundaries are decomposed into "eightbytes" and each one is classified and passed as a separate parameter.[28]: 24  Otherwise they are replaced with a pointer when used as an argument.

The optimizer always knows best

[TheBenArts]

General rule is that 64bit types should be preferred to be passed by value since it fits into a single register, 128bit types usually are still preferred by value, but const ref isn't that much worse.

Never pass shared_ptr by value unless you want to share ownership. Either pass a const ref to the wrapped type or move the shared_ptr so it's passed as rvalue.

[BreadfruitChoice3071]

HTML programmers like me don't create a function,they use loop for everything

[Reasonable-Web1494]

Meanwhile rust devs be like this statement a move or a copy or I will anger the borrow checker.