如何区分c中函数的INPUT，OUTPUT和INPUT-OUTPUT参数？

Question

reading "Software Detailed Description" Documents of some software modules, I see in the description of each function:

1. INPUT PARAMETER: .....
2. OUTPUT PARAMETER: .....
3. INPUT-OUTPUT PARAMETER: .....

For Example, we have the following:

typedef struct
{
    u16_t elementA;
    u16_t elementB;
    u8_t  elementC;

} myStruct;


void somefunction(myStruct *pToMyStruct)
{

   pToMyStruct->elementA  = 1;
   pToMyStruct->elementB  = 5;
   pToMyStruct->elementC  = 7;
}

In the Software Description Document, following is described:

1. INPUT PARAMETER: none
2. OUTPUT PARAMETER: none
3. INPUT-OUTPUT PARAMETER: pointer to structure (pToMyStruct)

I'm not so deep with the c programming technique, but why is in this case the "pToMyStruct" an INPUT-OUTPUT Parameter? Why is it not only an INPUT parameter? How can I, as a not experienced programmer but understand the code, easily identify these 3 types of parameter in an function? INPUT parameters for example are only modified within it's own function, or?

Will be thankful!

Answer 1

// INPUT-OUTPUT PARAMETER: pointer to structure (pToMyStruct)
void somefunction(myStruct *pToMyStruct) {
   pToMyStruct->elementA  = 1;
   ...
}

"Why is it not only an INPUT parameter?" - technically you are correct: it is only an input parameter. The only output of a function is its return value and its affect on the global environment (global variables, printf() , etc.)

The "Software Detailed Description" (author) is stuck with "C-does-not-have-pass-by-reference", so wants to create a new "point-of-view". As in: let us call input pointer parameters as a pseudo pass-by-reference which is: input, output or IO. Author wants you to document to that model.

// the return value is an output
int foo()

// x is an input parameter
void foo(int x)

// what x points to is an input parameter, be it an `int` or array of `int` or NULL
void foo(const int *x)

// what x points to is an output parameter 
void foo(int *x) {
  // *x not read before being set

// what x points to is an I/O parameter
void foo(int *x) {
  // *x read before being set

So myStruct *pToMyStruct is either an output or IO parameter. If one does not probe into the body of the function, safer to classify it as IO as the function signature does allows reading and writing to *pToMyStruct . Given the trivial example function, it is an output parameter.

Answer 2

That is because a pointer to the structure is being passed, and it is not const -qualified. Here are the rules

1. input: A normal argument, that the function does not modify. This can be a const pointer.
2. output: A pointer to a variable that the function will modify when it returns. Before you call the function, the variable is uninitialized.
3. input-output: A combination of the above two. You pass a pointer, that already points to valid data, and when the function returns, the data will be changed in some way. The swap function is a good example of this.

Answer 3

As said in the description, pToMyStruct is a pointer, which means the parameter is actually a memory address of the structure's data. Thus, the data transmitted can be used but also modified, that's why it's an INPUT-OUTPUT parameter.

An INPUT parameter would be a parameter that could not be modified in the function, like a normal variable.

A simple OUTPUT parameter is, basically, the value returned by the function.

The problem is that functions often need to have several OUTPUT variables. To do that, one must use pointers given as parameter. So, unless you have a really good understanding of the code, you cannot deduct whether a pointer in the parameters is just INPUT, OUTPUT or INPUT-OUTPUT. The only way to know it for sure is to look into the documentation as you did for your example.

Answer 4

input - you are only passing a value/argument to the function. output - The function will update the value of the variable passed(This is possible only with a pointer in C and pointer or reference in C++) intput and output - The same variable can be used to pass value and also to get updated values and the variable type is same as o/p.

In your code, a structure variable is passed and you are getting an updated structure in your function where you call somefunction(). Hence it is input and output variable.

Answer 5

Parameters in C are always passed by copy. When you use a pointer, it does a copy of the pointer which "points" to the same object. Then if you modify the content of the "copy of the pointer" it will modify the "real object".

Consequently, it is an input/output parameter (as it is possible to modify it).

If you had instead

void somefunction(myStruct theStruct)

then it is the structure itself which will be copied; then it will be an input parameter.

Answer 6

Contrary to some other languages, C (as well as C++) doesn't really have a keyword to indicate, what parameter is what, but as a rule of thumb:

• input parameters are usually pointer to const (or passed by value)
• you should avoid pure output parameters if possible and use the return value instead (thats what they are there for).
• So unless documentation states otherwise or the function name makes it obvious, I'd assume that a pointer to non-const parameter represent input-output-parameter.

---

Edit:
I should mention that the second (and consequently the third) point might be somewhat controversial as there are a lot of APIs that use pure output parameters - some for good reason (eg because they use the return value to indicate failure or success), some because they date back to times, when compilers where a lot dumber and this was actually an inportant performance optimization.

Answer 7

but why is in this case the "pToMyStruct" an INPUT-OUTPUT Parameter? Why is it not only an INPUT parameter? How can I, as a not experienced programmer but understand the code, easily identify these 3 types of parameter in an function? INPUT parameters for example are only modified within it's own function,

I like this question. Perhaps it is too broad to answer in just a few ideas, but here are some to get started with:

• Idea 1 - A formal parameter that can not be modified by the function / method, can only be input to the function or method.

Thus "const T formalParam" is clearly an input ... the const is commanding the compiler to declare an error if the function attempts to modify the const T formalParam.

Likewise, "const T& formalParam" is an input. Some people use this parameter style to provide access to a large data item while avoiding the cost of copying.

---

• Idea 2 - A formal parameter which is a copy of the actual parameter, as in pass-by-value, can only be input to the function or method.

Thus in "void foo(int t1);", the formal parameter t1 of type int is a copy of the actual parameter. Changing t1 has no impact to the actual int. This parameter behaves as if it is a local automatic variable pre-initialized with a copy of actual parameter's value.

This also applies to passing class instances. So that "void foo (T t2)", the formal parameter is a copy of some actual parameter. Again, modifying the copy has no impact to the original, so this can only be an input.

---

• Idea 3 - A formal parameter which is a reference (or pointer) to an existing actual parameter, as in pass-by-reference (and perhaps you might say pass-by-pointer) can be an output or a input/output parameter.

So, in "void foo(int& t1, char* label)", both formal parameters can be either output or input/output. And you can only tell by looking at how the formal parameters are used in the method code.

---

• Idea 4 - Back when I first started with C++, I found studying the library functions informative. Some examples:

 void* memcpy( void* dest, const void* src, size_t count ); // wrt memcpy: ^^output ^^^^^input ^input:pass-by-value // Note direction: to <---move <---from // I think this right-to-left idea might be a trend in C (research?) // return would seem useless, but is sometimes convenient value: copy of dest int memcmp ( const void* lhs, const void* rhs, size_t count ); // ^^^^^input ^^^^^input ^input:pass-by-value // return is result of comparison negative: int, 0, positive int int isalpha( int ch ); // ^input:pass-by-value // return is 0 (false) or non-zero (true) //from std::string::find size_type find( const basic_string& str, size_type pos = 0 ) const; // ^^^^^ input ^input: pass-by-value // return is npos or index where str found 

---

• Idea 4 - Your next job may specify a sequence for input output and results in something called a "coding standard".

I have reviewed some of Google's coding standard, it is not hard to find. Books have been published on the subject. (research effort: Search for C++ coding standards, or perhaps C coding standards, and review.)

• Idea 5 - consult others

I prefer that the return value of my methods to be a "status", and not the result of the method or function. (status means GOOD or FAIL) As a result, if my code outputs something, it then must have at least 1 output parameter, but methods often modify a data attribute of the class instance (instead of an output parameter). I generally arrange them as:

 T foo ( <input parameters> , <output parameters> ); 

T can be any class which has a simple and quick evaluation. Lately, I have used std::string, and when the string.size() is 0, it means there were no errors during the function. When size is positive, the string contains an error message for reporting.