Do function parameter variables always require a & or * operator?

I'm reteaching myself C++ and as I'm reading about pointers a question has came into mind.

When declaring function signatures in C++, the address-of and dereference operators are used, such as the below.

int someFunction(std::vector<int>& nums) {
     //do stuff 
}

In this context the & is being used to declare that the address of the nums variable is being used rather than the value.

If this signature is changed to the below, the value is being used instead.

int someFunction(std::vector<int>* nums) {
     //do stuff 
}

However if the below is now used, I assume the value of the nums variable is still being used despite the lack of operator.

int someFunction(std::vector<int> nums) {
     //do stuff 
}

If this is true, since the lack of an operator and the * operator both result in the same thing, why is there any need for the * operator at all? Is it simply for brevity?

Those * and & in your code are neither dereference nor address-of operators. Both, * and & can have different meanings. Here they are part of the type:

int x;      // declares an int
int* p;     // declares a pointer to int
int& r = x; // declares a reference to int

The address-of and dereference operators come into play for example when you assign something to the above variables:

p = &x; // here & is address-of operator
x = *p; // here * is dereference operator

> int someFunction(std::vector<int>& nums) {
> //do stuff
> }
> In this context the & is being used to declare that the address of the nums variable is being used rather than the value.

No. Here the & means that nums is passed as reference.

> If this signature is changed to the below, the value is being used
> instead.
>
> int someFunction(std::vector<int>* nums) {
> //do stuff
> }

No. Here nums is passed as pointer.

Only this is pass-by-value:

> int someFunction(std::vector<int> nums) {
> //do stuff
> }

You are confusing things. In C++ arguments passed to a function are copied into the function. This is called "passing arguments by value", which is Ok for small types such as primitive types (int, double, etc), but it might be very costly for large objects. Imagine if your std::vector has 10 million elements.

In the first case with int someFunction(std::vector<int>& nums) the & indicates to the compiler that you want to pass the argment nums by reference, instead of the default by value. That means that the vector will not be copied into the function and a reference will be used instead (the cost here is like copying a single pointer). Note that since you are using a reference, if you modify nums inside your function the change will be visible outside the function (the variable passed as argument to the function will be changed). This is sometimes what you want and sometimes it is not. If you want to avoid the copy but don't want to change the vector, use int someFunction(const std::vector<int>& nums) instead.

In the second case you are actually passing just a pointer to the function and not a std::vector<int>, although the pointer points to an std::vector<int>. Similarly to the previous case, only a pointer is copied no matter how many elements the vector has and any change you made the the pointed vector will be visible outside the function. Note, however, that pointers can be null, while references cannot. That means that you would need to check if the pointer is null.

The third case is the default "passing by value" and a vector is copied into the function. Any change you make in the vector will not be visible outside the function, since you only changed the copy. But the cost can be high if the vector as many elements.