Test s for prime or not?


#include<stdio.h>
void main(void)
{
           int no,rem,cnt;
        Printf("enter No");
        scanf("%d",&no);
        cnt=2;
        while(cnt<=no)
       {

              rem=no % cnt;
              if (rem==0)
              {
              printf("No is not prime");
              exit(0);
              }
              cnt++;
        }
          printf("No is Prime");
}

A dialog box is a window that pops up in response to user action to inform the user with a message. E.g. if the user does not save the document and exists the application the window pops up asking if he wants to save the document. This window is the dialog box. Modal Dialog: A modal dialog box disables the window to which it is assigned until the user dismisses the dialog box. E.g. The dialog that gets displayed with "yes"/"no"/"cancel" when you try to exit MS Word without saving the document is a modal dialog box.  A model dialog box is created by calling the doModal() function of the dialog class. This function does not return back control to the caller until the dialog is dismissed. E.g. CDialog dlg; dlg.doModal();  Modeless Dialog: A modeless dialog box is just the reverse of modal. It allows the user complete control of the application which owns it and the user can continue his work without closing the dialog. A modeless dialog box can be created using the Create () command of CDialog class. The Create() call returns as soon as the dialog box is created. Hence the control returns back to the caller and the user is able to continue using the application.

Does nothing ! If used, must be the only sentence within a paragraph.

Does nothing ! If used, must be the only sentence within a paragraph.

The RETURN statement terminates the operation and exits out of a stored procedure or batch operation. RETURN also allows you to return a value to the  calling batch or stored procedure. The BREAK statement exits out of a while loop.

True or false : the exit () function causes an exit from a function.

False : it cause a return to the beginning of the loop

Gracefully  restarts  the  Apache httpd daemon. If the daemon is not running, it is started. This differs from a
normal  restart in  that  currently  open  connections  are not aborted. A side effect is that old log files will  not
be  closed  immediately. This  means that if used in a log rotation script, a substantial delay may be necessary to ensure that  the  old  log  files  are closed before processing them. This command automatically checks        
    the configuration files as in configtest before initiating  the restart  to  make sure Apache doesn?t die.
This is equivalent to apachectl -k graceful.
( excerpt from manual page of apachectl )
Actually it sends a SIGUSR1 for a restart. The USR1 or graceful signal causes the parent process to advise the children to exit after their current request (or to exit immediately if they're not serving anything). The parent
re-reads its configuration files and re-opens its log files.As each child dies off the parent replaces it with a child
from the new generation of the configuration, which begins serving new requests immediately.

entry load are those charges which is levied on investor when he buy any mutual fund from distributor companys.
exit load charges are those when invesstor surrender their mutual fund to distributor co.'s.

Memory leak is - dynamically allocating memory and forgeting to free it. In C++, using a new operator to allocate a chunk of memory, and forgetting to delete it. There are several reasons this could occur. Some of them are,
1. Allocate a chunk of memory and assign the starting address to a pointer variable, and later, reassing another address to the same pointer without freeing its original address
2. Allocate memory for an array and not using proper delete method (delete[]) to free the memory
3. Unhandled exceptions - allocating memory and deleting it at the end of the program, but the program abnormally terminates (crashes) before the delete code line is executed.

Some of the ways of avoiding memory leaks within a class object are
1. Allocate all dynamic memory required for the class in the constructor, and delete it in the distructor
2. Use TRY/CATCH blocks around all statements where there is a possiblity of a crash
3. Override new operator for your class and Track memory allocations and pointers. Override delete operator and untrack the deleted/freed memory. In the destructor, check to see if there are any tracked memory locations (not freed) and free them up.
But beyond all these, it's still a good programming style that avoids memory leaks, because beyond objects, there is a program where you instantiate and run these objects. If you are allocating memory dynamically in the parent program, then carefully make sure you delete those chunks at all exit points (or centralize your exit point).