Thread: Is there a standard function?

Originally Posted by frktons

I've taken into account the fact that this is an evolving function that
will be ready some weeks forward in the future. The final idea is that I'll use a structure
with these variables, and the prototype of the function, and all of them
will be in a header.

The function will be called with a pointer to the structure.

Good to hear, but as you evolve the design, avoid evolving it to a worse state. A such, if you need to give the function many parameters for now, go ahead.

By using global variables unnecessarily, you would be evolving it to a worse state.

Code:

void   int_format(int num, bool sign, char sep)
{
    char buffer[15];
    // ...
}

What is so difficult?

Ignore part 5 for the time being. You then only need 4 parameters.

EDIT:
Elysia's example probably will not work: you should pass a pointer to the first character of the buffer to the function so that you can write to it, with the result reflected in the caller. You can assume that the caller provides a string with sufficient space.

Ah, then I misinterpreted what you needed it for.
Then more correct would be:

Code:

void   int_format(int num, bool sign, char sep, char buffer[], size_t size_of_buffer)
{
    // ...
}

Originally Posted by frktons

I'm thinking about pros and cons of passing arguments by value and by reference.
If I am concerned with performance, I'd avoid passing arguments by value.

You only need to be concerned about this when passing arguments that are struct objects. Since you have not even defined your struct yet, do not be concerned about this as it would be pre-mature optimisation.

Originally Posted by laserlight

You only need to be concerned about this when passing arguments that are struct objects. Since you have not even defined your struct yet, do not be concerned about this as it would be pre-mature optimisation.

Some programmers put comments in parts of their programs to remember that
in those points of the code they need to make some change/improvement.

I'm just doing the same, using both comments and declarations of variables
that I'm going to move elsewhere. Thinking about the present, I chose global
variables because they are faster, and I'd like the function would be 2 - 3 times
faster when I'm finished.

You can call it pre-mature optimization, or you can call it the direction you intend
to follow? Maybe both.

By the way, any other suggestion about performance or anything else?
How would you move if you wamt to have a better performance?

Well I actually need also point 5: I need to tell the function if I'd like the
formatted number being right or left aligned as well.

Originally Posted by frktons

Thinking about the present, I choosed global
variables because they are faster

That is maybe okay if:
1) the scale of the whole program is not too big
2) this is the central operation of the whole program
3) the function in question is very short and called many times repeatedly

Otherwise, the use of globals is no optimization at all, it's just messy and pointless. It seems to me you are developing a general purpose function which you might use in some other, larger project, so in fact the use of globals here is very inappropriate.

Listen, you don't know if it's a bottleneck or not. Premature optimizations leads to bad code. Just don't do it.
It is better to create readable and easy-to-understand code and stick to standards when coding. You can then measure with a profiler to find real bottlenecks later if performance is an issue.
Just for the sake of it, I can give you some more info to make you doubt:
- Global variables aren't necessarily better. Why? Because they can be modified everywhere, the compiler cannot assume certain things that it can on local variables. Hence it cannot perform some optimizations.
- Passing things by address also causes overhead because you must dereference the pointer everytime you use it. Variables passed by value does not have this overhead.
- Of course, passing by value means that a copy of the variables needs to be made, which costs time. But pointers also has to be copied.
So you see, it isn't as black and white as you would like it.

As for the size_t size_of_buffer:
It's the size of your buffer that you pass in. Use it to make sure you don't cause a buffer overrun.
I highly recommend that you write routines for all kinds of copying that makes an assertion if you are trying to copy more data than there is room for. It will save you time hunting down bugs and will increase the security of your application.

Originally Posted by MK27

That is maybe okay if:
1) the scale of the whole program is not too big
2) this is the central operation of the whole program
3) the function in question is very short and called many times repeatedly

Otherwise, the use of globals is no optimization at all, it's just messy and pointless. It seems to me you are developing a general purpose function which you might use in some other, larger project, so in fact the use of globals here is very inappropriate.

Yes MK27, you are absolutely right.

1) a program that print numbers, a lot of, I mean on real paper.
2) in practice yes, other than read a file and print it.
3) maybe 5 times for each data record, thousands of them