I am working on a project where code optimization plays a
vital role to get the required performance.
I would like to know is there any possible to reinitialization an
array of big size to zero with a single statement.

For example
main()
{
        int i =0;
        char A[30];
while(condition)
{
//Start
for( i = 0; i < 30; i++)
{
    A[i] = 0;

       for(i = 0; i < 30; i++)
      {
          printf(" enter a value in the index %d:\n",i);
          scanf("%d", &A[i]);
      }
/*followed by few other statements*/

try using memset ..

#include <string.h>
memset(A, 0, sizeof(A));

1) place the array declaration inside of a block (while block in this case)
and give an initialiser.
char A[30]={0};
This will set all the elements to zero (not just the first one), whenever
the path of execution enters the block.

2) since you have a char array, you can do a memset(A,0,sizeof(A)),
which is just equivalent to your for loop:

Using either of these may or may not improve the performance, but will
simplify the source code. Measure the times and check if zeroing out
an arry is the actual bottleneck or some something else. (Use a profiler,
if you have not already been using one yet.)

  int main(void)

Your version was outdated even in C89.

Richard

On the platform I have at hand (linux/x86_64/gcc 4.1 -O) I compiled the
following program:

#include <string.h>
enum { N = 32 };
void dummy(char *);

void a()
{
    char a[N]={0};
    dummy(a);

N=32 is likely to be faster than N=30.

How my implementation was managing with this code sniplet is irrelevant,
of course. But it illustrates that the function calls, loops that one
has in mind when programming, are not in one-to-one correspondence with
the machine-code-level function calls and loops. The C standards deliberately
allow the implementations to do 'as if' they did what the programmer meant.

I know you said you didn't want a function call, but nothing you can
come up with is likely to be faster than calling memset().

If your array is large, any overhead from the function call will be
insignificant.  If your array is small, the time spent for the entire
operation will probably be insignificant.

For that matter, since memset() is a standard function, the compiler
is permitted to use its knowledge of memset()'s semantics to generate
special-case code to perform the equivalent actions.  There might not
even be a function call.

I can think of one possible alternative that doesn't use either an
explicit loop or an explicit function call:

    #define ARRAY_LEN 1000
    struct s {
        int arr[ARRAY_LEN];
    };
    struct s s_zero = { 0 };
    struct s obj;

    /* ... code that works with obj.arr ... */

    obj = s_zero;

This works because struct assignment is built into the language,
whereas array assignment isn't.  (Note: don't try to use pointer casts
to apply this to an array object; the struct assignment will also copy
any padding bytes, and if the array isn't part of a struct that could
clobber other memory.)

*However*, when I compiled the above code using one particular
compiler, the initialization of s_zero was implemented as a call to
memset(), and the assignment was implemented as a call to memcpy().

You're assuming that the overhead of a function call is going to be
unacceptable, but *how do you know*?  Have you actually measured your
code's performance and found it to be unacceptably slow?  If not,
don't waste your time trying to improve it until and unless you know
there's a problem to be solved.    

The two rules of program optimization are:

Rule 1: Don't do it.

Rule 2 (experts only): Don't do it yet.

memset is only useable on arraays of type char. For any other type
you'll enter undefined behavior because this is the only type memset
accepts and there is no other type available that can set type int,
float, double and theyr modifications to the right type of 0. Any type
except char can contain padding bits. Having all padding bits set to 0
may end up in trap when accessing the value.

--
Tschau/Bye
Herbert

(And I imagine a static initializer might have some cost when the
program is being loaded, but it's probably ok to ignore that.)

Using two separate objects rather than reinitializing one and using it
again might be faster, at some cost in memory usage.  It's unlikely to
be significantly helpful.

    For any integer type, the object representation where all the bits
    are zero shall be a representation of the value zero in that type.

I believe that all existing implementations (happen to) obey this rule
anyway, so for practical purposes you're safe in assuming that
all-bits-zero is a representation of 0 for any integer type (but not
for floating-point or pointer types).