Question

Does a set of functions doing exactly one word but differing in the name like atoi , atol, atoll etc called theoretically polymorphic?

For example I have a function say swap which needs to operate on different kind of data types. So i have one function/operation for which i have different implementations, but unfortunately because the language does not support using the same function name, to get such functionality i need to make variants swap_i , swap_l, swap_f, swap_str etc etc, and have to call them manually depending on the operands.

When designing the code, one would have designed this as one function, with different implementations, which are invoked depending upon the operands. But in this case the programmer instead of the compiler needs to make the static binding of the functions.
If the programmer implemented it in C++ then the design would be the same (as he/she has followed an OOD approach), but in this case the static binding could be done by the compiler without bothering the user.

Now, if in the design approach swap was a polymorphic function, will such a difference in C and C++ design implementation will make the difference, so that we cannot call such a C implementation not polymorphic and the C++ implementation polymorphic ?

EDIT1:

Another example:

say we send a union with different possible data types packed in and a structure wrapping it with a variable indicating which component of the union to be used. Then we can use only one function name swap without variants. After we receive the structure in the function, we can internally do operations depending on the datatype active in the union

  struct _generic {
     int type;
     union {
              int a;
              float b;
              char c;
     } component;
  } variable;

  swap (struct _generic var2, struct _generic var1)
  {
     if (var1.type == INTEGER)
     {
         /* code for integer */
     }
     else if (var1.type == FLOAT)
     {
        /* code for float */
     }
      .
      .
      .
  }

In this case we use another way.

Also note the ellipses operator ... like in printf with this also we can get some builtin feature.

The main point is that, C language does not provide direct implementation of OOD s , but can we use the OOD terminology on the implementation on the C implementation, if it is designed by following an object oriented design?

Answer 1

In my opinion it is not incorrect, because the polymorphism and other object oriented terminologies are not something which is language dependent, and is a concept. Now, different languages provide different features with which the implementation of an object model is much easier, and some features are only possible which were not possible in other languages.

If one problem was modelled with OOD approach, and the same model is followed to make an implementation with C and C++ keeping the approach identical, where the difference only comes from the limited feature set of the language, and then they are compiled then both generate assembler code. The C++ outputs for a polymorphic function are not polymorphic anymore after it is converted to the asm.

The difference is that C does not provide features to implement OOD as easier as it can be done in C++ or other OOP languages.