Passing variable number of arguments to a C/C++ function like printf().

-




Introduction



Many of us might have wondered at sometime or the other about how to pass a variable number of arguments to C++ functions : something like a printf function. I don't know how many are aware of this, so I decided to post an article on this topic.

Background



When a function is declared, the data-type and number of the passed arguments are usually fixed at compile time. But sometimes we require a function that is able to accept a variable number of arguments. The data-type and/or number of the passed arguments are provided at the run-time.

Through this article, I will try to show you how to create a C function that can accept a variable number of arguments.

The secret to passing variable number and type of arguments is the stdarg library. It provides the va_list data-type, which can contain the list of arguments passed into a function.
The stdarg library also provides several macros : var_arg, va_start, and va_end that are useful for manipulating the argument-list.

Functions of the macros :
(1) va_start is a macro used to initialize the argument list so that we can begin reading arguments from it. It takes two arguments : (a) the va_list object which stores the passed arguments, and (b) the last named argument, after which the number of arguments is variable.
(2) va_arg is the macro used to read an argument from the list. It takes two parameters: (a) the va_listobject we created, and (b) a data type. va_arg returns the next argument as this type.
(3) va_end is a macro that cleans up our va_list object when we're done with it.

The code



I will clarify the concept with 2 examples.

Example 1 : A function accepts variable arguments of known data-type
(A simple average function, that takes variable number of arguments)



#include <stdio.h>
#include <stdarg.h>

float avg( int Count, ... )
{
      va_list Numbers;
      va_start(Numbers, Count);
      int Sum = 0;
      for(int i = 0; i < Count; ++i )
            Sum += va_arg(Numbers, int);
      va_end(Numbers);
      return (Sum/Count);
}

int main()
{
      float Average = avg(10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
      printf("Average of first 10 whole numbers : %f\n", Average);
      return 0;
}


Output of the above code is :
Average of first 10 whole numbers : 4.000000


Example 2 : A function accepts variable arguments of unknown data-type
(A simple print function, that takes variable number and variable type of arguments)


#include <stdio.h>
#include <stdarg.h>

float Print( const char* Format, ... )
{
      va_list Arguments;
      va_start(Arguments, Format);
      double FArg;
      int IArg;
      for(int i = 0; Format[i] != '\0'; ++i )
      {
            if (Format[i] == 'f')
            {
                  FArg=va_arg(Arguments, double);
                  printf("Caught a float : %.3lf\n",FArg);
            }
            else if (Format[i] == 'i')
            {
                  IArg=va_arg(Arguments, int);
                  printf("Caught an integer : %d\n",IArg);
            }
      }
      va_end(Arguments);
}

int main()
{
      Print("This is funny, isn't it ?", 1, 2, 12.1200, 3, 4);
      return 0;
}


Output of the above code is :
Caught an integer : 1
Caught an integer : 2
Caught a float : 12.120
Caught an integer : 3
Caught an integer : 4


Hope this article will be useful to you.

Thanx for reading it ! 

Good bye and take care ! 

Comments

Post a Comment

Popular posts from this blog

C++ Guidelines for Multithreaded System

-
Image
Mutithreading è Parallelism è  Achieve concurrency. Below are some of the guidelines to follow for building C++ Multithreaded system. Ø std::thread function arguments are pass by value by default. Thread function arguments are pass by value by default. So, if you want the change to be persisted in the arguments passed in , then pass them by reference using std::ref(). Ø Protect shared data or resource using critical section.     In a multithreaded environment if there are more than one thread sharing the resource/data then often it results in a undefined behaviour if the resource/shared data is not protected using synchronise mechanism. So, the shared resource/data must be protected with std::mutex . Ø Release lock after critical section. If a thread T1 acquires lock (mutex.lock()) before entering critical section and forgets to unlock(mutex.unlock()) then all the other threads will be blocked indefinitely and the program might hang because thread T1 gets hol
Read more

Signalling System #7(SS7) Protocol.

-
Image
            Signaling System No. 7 ( SS7 ) is a set of telephony signaling protocols which are used to set up most of the world's public switched telephone network telephone calls. The main purpose is to set up and tear down telephone calls. Other uses include number translation, prepaid billing mechanisms, short message service (SMS), and a variety of other mass market services. SS5 and earlier systems used in-band signaling(In telecommunications, In-band signaling is the sending of metadata and control information in the same band, on the same channel, as used for data.). SS6 and SS7 implement out-of-band (out-of-band control signaling, signaling bits are sent in special order in a dedicated signaling frame.) signaling protocols.         The term signaling , when used in telephony, refers to the exchange of control information associated with the establishment of a telephone call on a telecommunications circuit. An example of this control information is the digits dialed by t
Read more

std::shared_ptr

-
Image
std::shared_ptr  for shared ownership An object accessed via std::shared_ptr s has its lifetime managed by those pointers through shared ownership. No specific std::shared_ptr owns the object. Instead all shared_ptr’s pointing to it collaborates to ensure its destruction at the point where it’s no longer needed. When the last shared_ptr pointing to an object stops pointing there, that shared_ptr destroys the object it points to. A shared_ptr can tell whether it’s the last one pointing to a resource by consulting the resource’s reference count, a value associated with the resource that keeps track of how many shared_ptrs point to it. Shared_ptrs constructors increments this count shared_ptr s destructors decrements it and copy assignment operators do both. If sp1 and sp2 are shared_ptr s to different objects, the assignment “ sp1=sp2 ” , modifies sp1 such that it points  to the object pointed to by sp2 . sp1 reference count is decremented, while that for the object point
Read more