#include "stdio.h"
#include "conio.h"
#include "string.h"

void delchar(char *x,int a, int b);

void main()
{
     char string[10];
     int n,pos,p;
     clrscr();

     puts("Enter the string");
     gets(string);
     printf("Enter the position from where to delete");
     scanf("%d",&pos);
     printf("Enter the number of characters to be deleted");
     scanf("%d",&n);
     delchar(string, n,pos);
     getch();
}

// Function to delete n characters
void delchar(char *x,int a, int b)
{
  if ((a+b-1) <= strlen(x))
  {
    strcpy(&x[b-1],&x[a+b-1]);
    puts(x);
    }
}

The post Program to delete n Characters from a given position in a given string using functions first appeared on Student Projects.

1.Macro consumes less time:
When a function is called, arguments have to be passed to it, those arguments are accepted by corresponding dummy variables in the function. Then they are processed, and finally the function returns a value that is assigned to a variable (except for a void function). If a function is invoked number of times, the times add up, and compilation is delayed. On the other hand, the macro expansion had already taken place and replaced each occurrence of the macro in the source code before the source code starts compiling, so it requires no additional time to execute.

2. Function consumes less memory:
Prior to compilation, all the macro-presences are replaced by their corresponding macro expansions, which consumes considerable memory. On the other hand, even if a function is invoked 100 times, it still occupies the same space. Hence function consumes less memory.

Example for Macro:
The following line defines the macro SUM, having two parameters a and b and the replacement tokens (a + b):

#define SUM(a,b) (a + b)

This definition would cause the preprocessor to change the following statements (if the statements appear after the previous definition):
c = SUM(x,y);
c = d * SUM(x,y);
In the output of the preprocessor, these statements would appear as:
c = (x + y);
c = d * (x + y);

Example for function:
In calling program function call would appear as,

c=SUM(x,y);

Where sum is the name of the function. And x, y are the arguments passed from calling program to called program.
This statement will invoke the following function SUM. Hence x, y are copied to dummy variables a and b. And then function computes the sum and stores the value in c, which will be returned back to the calling program.

int sum(int a, int b)
{
int c;
c=a+b;
return c;
}

The post What is the difference between macro and function? first appeared on Student Projects.

1. Operator new constructs an object (calls constructor of object), malloc does not. Hence new invokes the constructor (and delete invokes the destructor)This is the most important difference.
2. operator new is an operator, malloc is a function.
3. operator new can be overloaded, malloc cannot be overloaded.
4. operator new throws an exception if there is not enough memory, malloc returns a NULL.
5. operator new[] requires you to specify the number of objects to allocate, malloc requires you to specify the total number of bytes to allocate.
6. operator new/new[] must be matched with operator delete/delete[] to deallocate memory, malloc() must be matched with free() to deallocate memory.

Syntax of new is:
p_var = new type name;
Where p_var is a previously declared pointer of type typename. And typename can be any basic data type.

Example:
int  *p;
p = new int;
It allocates memory space for an integer variable.

Syntax of malloc is:
p_var = (typename *)malloc(sizeof(typename));
Where p_var is a previously declared pointer of type typename. And typename can be any basic data type.

Example:
int *p;
p = (int *)malloc(sizeof(int));
This statement “allocates” or “reserves” a block of memory for an integer from the heap. Then it places the address of the reserved block into the pointer variable (p, in this case).

The post What is the difference between new and malloc? first appeared on Student Projects.