How to add two dynamic vectors?

As Jack the Ripper said , let's go by parts:

is it correct to use more than three parameters in a function/procedure?

Well, like almost everything... it depends .

logical factors.

In the answer you indicate, they are referring to logical problems ; that is, using too many arguments may indicate poor function design. Perhaps that function is doing too much work, and it would be wise to break it down into several smaller functions.

This is not always the case : some functions simply require a certain number of arguments to work (such as your own sumar_vectores( ).

However, there are mechanisms to facilitate the use of such functions; as indicated in the answer itself, it is very common to use complex data types, such as struct(in C) or class(in C++).

To keep things short: instead of creating a function with 5 arguments, you create a function with struct5 classfields , fill it, and pass it as the only argument.

physical factors

This is a different point of view. On certain architectures, using fewer arguments can speed up the function call.

For example, on x86, the fastcall calling convention uses 3 registers (I think it was 3, not sure) to pass the first 3 arguments, and pushes the rest on the stack. In contrast, cdecl or pascal push all arguments on the stack, so they are slower. By the way, fastcall is used by default ;-)

Pushing onto the stack is slower than using registers, since it involves memory reads/writes.

But... these behind-the-scenes things shouldn't concern you unless you're writing critical code (speed or size), and you can ignore them 99.99% of the time. The compiler is up to something, and it will take care of optimizing the code as much as it can.

Also, C++ can use functions inline, which don't even involve a true call . Come on, you can ignore the physical issue ... although I think it's worth knowing, since we're dealing with the matter :-)

How could I modify the definition of the void add_vectors procedure so that it uses three or fewer parameters?

Well, as I said before... it depends .

You're in C++... Use classes!

In your case, you could do

struct Vector {
  size_t m_size;
  int *ptr;
};

The above can perfectly be used for what you intend. And, by using classes, you save the last argument of your call, which would have only 3 arguments:

void sumar_vectores( const Vector &v1, const Vector &v2, Vector &v3 );

And, while we're at it, I challenge you to implement this:

Vector sumar_vectores( const Vector &v1, const Vector &v2 );

With what you save another one more; and even, overloading the operator+( ):

Vector v3 = v1 + v1;

So you still use 2 arguments, but it looks prettier :-)

Speed ​​or size?

Another way to attack your specific case is to use a special value to indicate the end of the vector ; for example, use -1as an indicator.

So, when filling, when the user finishes typing, you manually put a -1in the array.

Now, you can also save the last argument of your function... at the cost of having to calculate, each time , the size of the vector, counting the elements until you get to -1.

So your function would be

void sumar_vectores( int v1[], int v2[], int v3[] );

Of course you could also take advantage of the function's ability to return things:

int *sumar_vectores( int v1[], int v2[] );

and you would be left with only 2.

Already put ...

Sticking with your specific case, you could still change the logic behind your vectors ; in your code, the size of the vector is saved in a variable for that purpose... can't you save that size in the vector itself? Specifically, in the position vector[0].

With this, your function remains the same as in the previous case:

int *sumar_vectores( int v1[], int v2[] );

But now you don't need to calculate the size on each call... instead, your actual data starts at position vector[1].

And the control logic of your vectors gets a bit complicated; for example, to create a 7-element array :

int *v7 = new int[8];
*v7 = 8; // Indicas el tamaño.

Now to finish and curl the curl a little more:

int *v7 = new int[8];
*v7 = 8; // Indicas el tamaño.
++v7;

With this last step, your vector can be used transparently with other functions, but you know that to get the size, just do

int tam = *( v7 - 1 );

_{Ummm... I think this question will end up being closed for opinion based or too broad :-O}

Is it okay to use more than three parameters in a function/procedure?

There is nothing wrong with it, and there is nothing right with it either because it is not a correctness problem. The answer you linked (from SoftwareEngineering) talks about Uncle Bob 's Clean Code book as a reference for determining the number of parameters in a function, but there are several reasons why that answer has nothing to do with the fix:

• Clean Code is a book about writing clear, easy-to-understand code, not about writing correct code. The purpose of this book tends to be misunderstood and the book has been inappropriately held up as a programming bible.
• Code correctness cannot be universally established as it has a high dependency on the target of the code and external factors: what is correct in one context may be incorrect in another.

As a curiosity, the C++ standard indicates in Annex B that the parameters that a function can receive depend on the compiler implementation, but that they should be at least 256.

If you need 256 parameters in a function it doesn't mean it's wrong ¹ , but it will make the code extremely difficult to understand.

There is no need to reinvent the wheel.

The C++ Standard Library offers a wrapper that is intended precisely for operations like the ones you are doing: std::valarray, you can add two valarrayin the most natural way possible, using a plus symbol:

using intarray = std::valarray<int>;

intarray a({1, 2, 3, 4}), b({4, 3, 2, 1});
intarray c = a + b; // c contendra {5, 5, 5, 5}

¹ Surely indicates poor design decisions and/or absurd requirements.