Функции с переменным количеством параметров

Определите последовательность (формат) параметров и приведите пример вызова.

//--------------------------------------------------------1

void F1(char *p,...)

{ char **q;

for (q = &p; *q !=NULL; q++) cout << *q; }

//--------------------------------------------------------2

void F2(int *p,...)

{ int **q, i, d;

for (i=1, q = &p, d=*p; q[i]!=NULL; i++)

*q[i-1] = *q[i];

*q[i-1] = d;}

//--------------------------------------------------------3

int *F3(int *p,...)

{ int **q, i, *s;

for (i=1, q = &p, s=p; q[i]!=NULL; i++)

if (*q[i] > *s) s = q[i];

return s;

}

//--------------------------------------------------------4

int F4(int p[], int a1,...)

{ int *q, i;

for (i=0, q = &a1; q[i] > 0; i++)

p[i] = q[i];

return i;}

//--------------------------------------------------------5

union x { int *pi; long *pl; double *pd; };

void F5(int p,...)

{ union x ptr;

for (ptr.pi = &p; *ptr.pi != 0; )

{

switch(*ptr.pi++)

        {

case 1: cout << *ptr.pi++; break;

case 2: cout << *ptr.pl++; break;

case 3: cout << *ptr.pd++; break;

     }}}

//--------------------------------------------------------6

char **F6(char *p,...)

{ char **q,**s;

int i,n;

for (n=0, q = &p; q[n] !=NULL; n++);

s = new char*[n+1];

for (i=0, q = &p; q[i] !=NULL; i++) s[i]=q[i];

s[n]=NULL;

return s;}

//--------------------------------------------------------7

char *F7(char *p,...)

{ char **q; int i,n;

for (i=0, n=0, q = &p; q[i] !=NULL; i++)

if (strlen(q[i]) > strlen(q[n])) n=i;

return q[n];

}

//--------------------------------------------------------8

int F8(int a1,...)

{ int *q, i, s;

for (s=0, i=0, q = &a1; *q > 0; q++)

   s+= *q;

return s;}

//--------------------------------------------------------9

union xx { int *pi; long *pl; double *pd; };

double F9(int p,...)

{ union xx ptr;

double dd=0;

for (ptr.pi = &p; *ptr.pi != 0; )

   {

switch(*ptr.pi++)

     {

case 1: dd+= *ptr.pi++; break;

case 2: dd+= *ptr.pl++; break;

case 3: dd+= *ptr.pd++; break;

     }

   }

return dd;}

//------------------------------------------------------10

double F10(int a1,...)

{ double s,*q; int i,n;

for (s=0, n=a1, q = (double*)(&a1+1); n!=0; n--)

s += *q++;

return s;}

//-------------------------------------------------------11

double F11(int a1,...)

{ double s=0;

int *p=&a1;

while(*p!=0)

  {

  if (*p>0) s+=*p++;

  else

        { p++; s += *((double*)p)++; }

  }

return s; }

//--------------------------------------------------------12

double F12(char *p,...)

{ double s;

int *q=(int *)(&p+1);

for (;*p!=0; p++)

switch(*p)

  {

case 'd': s+=*q++; break;

case 'f': s+=*((double*)q)++; break;

case 'l': s+=*((long*)q)++; break;

  }

return s; }

//--------------------------------------------------------13

int F13(char *p,...)

{ int s=0;

int *q=(int *)(&p+1);

for(;*p!=0;p++)

if (*p>='0' && *p<='9') s+=q[*p-'0'];

return s;

}

//--------------------------------------------------------14

double F14(int p,...)

{ double dd=0;

int *q=&p;

for (; *q != 0; )

   {

   switch(*q++)

        {

   case 1: dd+= *q++; break;

   case 2: dd+= *((long*)q)++; break;

   case 3: dd+= *((double*)q)++; break;

        }

   }

return dd;}

Динамические массивы

//----------------------------------------------------- 1

char *F1(char *s)

{ char *p,*q; int n;

for (n=0; s[n] !='\0'; n++);

p = new char[n+1];

for (q=p; n >=0; n--) *q++ = *s++;

return p;

}

//------------------------------------------------------- 2

int *F2()

{ int n,i,*p;

cin >> n;

p=new int[n+1];

for (p[0]=n, i=0; i<n; i++)

  cin >> p[i+1];

return p; }

//------------------------------------------------------- 3

int *F3()

{ int n,i,*p;

cin >> n;

p=new int[n+1];

for (i=0; i<n; i++)

  { cin >> p[i]; if (p[i]<0) break; }

p[i]=-1;

return p; }

//------------------------------------------------------- 4

char *F4(char *p, char *q)

{ int n1, n2;

for (n1=0; p[n1]!=0; n1++);

for (n2=0; p[n2]!=0; n2++);

char *s,*v;

s=v=new char[n1+n2+1];

while(*p!=0) *s++ = *p++;

while(*q!=0) *s++ = *q++;

*s=0;

return v; }

//------------------------------------------------------- 5

double *F5(int n, double v[])

{

double *p=new double[n+1];

p[0]=n;

for (int i=0; i<n; i++) p[i+1]=v[i];

return p;

}

//------------------------------------------------------- 6

int *F6()

{ int *p, n=10,i;

p=new int[n];

for (i=0;;i++)

  {

  if (i==n) { n=n*2; p=(int*)realloc(p,sizeof(int)*n); }

  cin >> p[i];

  if (p[i]==0) break;

  }

return p;}

//------------------------------------------------------- 7

void *F7(void *p, int n)

{ char *pp, *qq, *ss;

qq = ss = new char [n];

for (pp=(char*)p; n!=0; n--) *pp++ = *qq++;

return ss;}

//------------------------------------------------------- 8

int *F8(int n)

{

int s,i,m,k,*p;

s = 10; p = new int[s];

for (i=2, m=0; i<n; i++)

{

for (k=0; k<m; k++)

if (i % p[k]==0) break;

if (k==m)

    {p[m++] = i;

    if (m==s)

          {

s=s*2;

p=(int*)realloc((void*)p,sizeof(int)*s);

}}}

return p;}

Массивы указателей

//------------------------------------------------------- 1

int F1(double *p[])

{ int n;

for (n=0; p[n]!=NULL; n++);

return(n); }

//------------------------------------------------------- 2

void F2(double *p[])

{ int i,k;

do {

k=0;

for (i=1; p[i]!=NULL; i++)

if (*p[i-1] > *p[i])

{ double *dd;

        dd=p[i]; p[i]=p[i-1]; p[i-1]=dd; k++;

}

} while k;}

//------------------------------------------------------ 3

void F3(double *p[], double *q)

{ int i,n;

for (i=0; p[i]!=0; i++)

  if (*p[i] > *q) break;

for (n=i; p[n]!=NULL; n++);

for (; n >=i; n--)

  p[n+1] = p[n];

p[i] = q;}

//------------------------------------------------------ 4

int F4(double **p[])

{ int k,i,j;

for (k=i=0; p[i]!=NULL; i++)

for (j=0; p[i][j] !=NULL; j++, k++);

return k;}

//------------------------------------------------------ 5

char **F5(char a[][80], int n)

{ int i; double **p;

p = new char* [n+1];

for (i=0; i<n; i++) p[i]=a[i];

p[n]=NULL;

return p;}

//------------------------------------------------------ 6

// strlen(char *) - длинастроки

char *F6(char *p[])

{ int i,sz,l,k;

for (i=sz=k=0; p[i]!=NULL; i++)

  if ((l=strlen(p[i])) >sz) { sz=l; k=i; }

return(p[k]); }

//------------------------------------------------------ 7

char **F7(char c[])

{ char **p; int i,n, cnt;

p = new char*[20];

for (i=n=cnt=0; c[n]!=0; n++)

  {

  if (c[n]==' ')

        { c[n]='\0'; cnt=0; }

  else

        {cnt++;

        if (cnt==1) p[i++]=&c[n];

        if (i==19) break;

        }

  }

p[i]=NULL; return(p);}

//------------------------------------------------------ 8

char *F8(char *p[], int m)

{ int n; char *q;

for (n=0; p[n]!=NULL; n++);

if (m >=n) return (NULL);

q = p[m];

for (n=m; p[n]!=NULL; n++) p[n]=p[n+1];

return q;}

//------------------------------------------------------ 9

// strcmp(char*,char*) - сравнениестрок

int F9(char *p[], char *str)

{ int h,l,m;

for (h=0; p[h]!=NULL; h++);

for (h--,l=0; h >= l;)

  {

  m = (l+h) / 2;

  switch(strcmp(p[m],str))

        {

case 0: return(m);

case -1: l = m+1; break;

case 1: h = m-1; break;

}

  }

return -1;}

//----------------------------------------------------- 10

// gets(char *) - ввод строки с клавиатуры

char **F10()

{int n; char **p, s[80];

p = malloc(100 * sizeof(char*));

for (n=0; n<99 & (gets(s),s[0]!='\0'); n++ )

  {

  p[n]=new char[strlen(s)+1];

  strcpy(p[n],s);

  }

p[n]=NULL; return(p); }

//----------------------------------------------------- 11

void F11(char *p[], int m)

{ int n; char *q;

for (n=0; p[n]!=0; n++);

if (m >= n) return;

for (; n > m; n--) p[n+1] = p[n];

p[m+1] = new char [strlen(p[m]+1)];

strcpy(p[m+1],p[m]);}

//----------------------------------------------------- 12

char *F12(char **p[], int n)

{ int k,i,j;

for (k=i=0; p[i]!=NULL; i++)

for (j=0; p[i][j] !=NULL; j++, k++)

  if (k==n) return(p[i][j]);

return(NULL);}