Информатика и технология программирования

         

Структура формальных параметров для функции




1-20. Вид файла (текстовый или двоичный). Структура данных в файле или формат данных.

21-30. Формат данных в памяти при работе с массивом переменного формата.

31-40. Структура формальных параметров для функции с переменных количеством параметров.

41-50. Алгоритм, реализованный рекурсивной функцией.





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

struct man { int dd,mm,yy; };
man *F(int n, FILE *fd)
{ man *p;
p = malloc(sizeof( man));
fseek (fd, (long)sizeof( man)*n, SEEK_SET);
fread (p, sizeof( man),1,fd);
return(p);
}
// 2------------------------------------------------------

void *F(FILE *fd)
{ int n;
void *p;
fread(&#38n,sizeof(int),1,fd);
if (n==0) return(NULL);
p = malloc(n);
fread(p,n,1,fd);
return(p);
}
// 3------------------------------------------------------

double *F(FILE *fd)
{ int n;
double *p;
fread(&#38n,sizeof(int),1,fd);
if (n==0) return(NULL);
p = malloc((n+1)*sizeof(double));
fread(p,sizeof(double),n,fd);
p[n]=0.0;
return(p);
}
// 4------------------------------------------------------

&#35define FNULL -1L
struct xxx { long fnext; };
xxx *F(int n,FILE *fd)
{ xxx *p;
long p0;
p = malloc(sizeof( xxx));
fseek(fd,0L,SEEK_SET);
fread(&#38p0,sizeof(long),1,fd);
for (; p0!=FNULL &#38&#38 n!=0; n--, p0 = p-&#62fnext)
{
fseek(fd,p0,SEEK_SET);
fread(p,sizeof( xxx),1,fd);
}
return(p);
}
// 5------------------------------------------------------

struct man { int dd,mm,yy; };
man *F(int n, FILE *fd)
{ man *p;
long fp;
p = malloc(sizeof( man));
fseek(fd, sizeof(long)*n,SEEK_SET);
fread(&#38fp,sizeof(long),1,fd);
fseek(fd,fp,SEEK_SET);
fread(p,sizeof( man),1,fd);
return(p);
}
// 6------------------------------------------------------

void *F(int n, FILE *fd)
{ int sz;
void *p;
fseek(fd,0L,SEEK_SET);
fread(&#38sz,sizeof(int),1,fd);
p = malloc(sz);
fseek (fd, (long)sz * n +sizeof(int), SEEK_SET);
fread (p, sz,1,fd);
return(p);
}
// 7------------------------------------------------------

void *F(int n, FILE *fd)


{ int sz;
void *p;
long p0;
fseek(fd,0L,SEEK_SET);
fread(&#38sz,sizeof(int),1,fd);
fread(&#38p0,sizeof(long),1,fd);
p = malloc(sz);
fseek (fd, p0 + sizeof(long)*n, SEEK_SET);
fread (&#38p0, sizeof(long),1,fd);
fseek(fd, p0, SEEK_SET);
fread(p, sz, 1, fd);
return(p);
}
// 8------------------------------------------------------

char *F( int n, FILE *fd)
{ char *p;
long fp;
int i;
fseek(fd, sizeof(long)*n,SEEK_SET);
fread(&#38fp,sizeof(long),1,fd);
fseek(fd,fp,SEEK_SET);
n = 80; p = malloc(n);
for (i=0;; i++)
{
if (i==n) p = realloc(p, n=n*2);
fread(p+i,1,1,fd);
if (p[i]=='\0') return(p);
}
return(p);
}
// 9------------------------------------------------------

&#35define FNULL -1L
char *F(int n, FILE *fd)
{ long p0;
int sz;
char *p;
fseek(fd,0L,SEEK_SET);
fread(&#38p0,sizeof(long),1,fd);
for (; p0!=FNULL &#38&#38 n!=0; n--)
{
fseek(fd,p0,SEEK_SET);
fread(&#38p0,sizeof(long),1,fd);
}
if (p0==FNULL) return(NULL);
fread(&#38sz,sizeof(int),1,fd);
p = malloc(sz+1);
fread(p,sz,1,fd);
p[sz]='\0';
return(p);
}
// 10--------------------------------------------------------

char *F(FILE *fd)
{ int n;
char *p;
fread(&#38n,sizeof(int),1,fd);
if (n==0) return(NULL);
p = malloc(n);
fread(p,n,1,fd);
return p;
}
// 11--------------------------------------------------------

void F(FILE *fd, char *s)
{ int n;
char *p;
fseek(fd,0L,SEEK_END);
n = strlen(s)+1;
fwrite(&#38n,sizeof(int),1,fd);
fwrite(p,n,1,fd);
}
// 12--------------------------------------------------------

double *F(FILE *fd)
{ int n, dn;
double *p;
fread(&#38n,sizeof(int),1,fd);
if (n==0) return(NULL);
dn = n / sizeof(double);
p = malloc((dn+1)*sizeof(double));
p[0]=dn;
fread(p+1,sizeof(double), dn, fd);
return p;
}
// 13--------------------------------------------------------

void F(FILE *fd, double *s, int dn)
{ int n;
n = dn * sizeof(double);
fseek(fd,0L,SEEK_END);
fwrite(&#38n,sizeof(int),1,fd);
fwrite(s,sizeof(double),dn,fd);
}
// 14------------------------------------------------------




void F(FILE *fd)
{ int n;
void *p;
fread(&#38n,sizeof(int),1,fd);
if (n==0) return;
p = malloc(n);
fread(p,n,1,fd);
switch (n)
{
case sizeof(int): printf("%d", *(int*)p); break;
case sizeof(long): printf("%ld", *(long*)p); break;
default: puts((char*)p); break;
}
free(p);
}
// 15------------------------------------------------------

char *F( int n, FILE *fd)
{ int m;
char *p;
long fp;
fseek(fd, sizeof(long)*n,SEEK_SET);
fread(&#38fp,sizeof(long),1,fd);
fseek(fd,fp,SEEK_SET);
fread(&#38m,sizeof(int),1,fd);
p=malloc(m);
fread(p,m,1,fd);
return p ;
}
// 16------------------------------------------------------

char *F(int n, FILE *fd1, FILE *fd2)
{
long pp;
char *q;
fseek(fd1,n*sizeof(long,SEEK_SET));
fread(&#38pp,sizeof(long),1,fd1);
q = malloc(80);
fseek(fd2,pp,SEEK_SET);
fgets(q,80,fd2);
return q;
}
// 17------------------------------------------------------

char **F(FILE *fd)
{ int n,m,i;
char **p;
long *fp;
fseek(fd, 0L,SEEK_SET);
fread(&#38n,sizeof(int),1,fd);
p = malloc(sizeof(char*)*(n+1));
fp = malloc(sizeof(long)*n);
fread(fp,sizeof(long,n,fd));
for (i=0; i&#60n; i++)
{
fseek(fd, fp[i],SEEK_SET);
fread(&#38m,sizeof(int),1,fd);
p[i]=malloc(m);
fread(p[i],m,1,fd);
}
p[n]=NULL:
return p ;
}
// 18------------------------------------------------------

&#35define FNULL -1L
struct ooo { ooo *p[20]; char *s; long fs; long fp[20]; }
ooo *F(FILE *fd, long pos)
{
int i,m;
ooo *q;
if (pos==FNULL) return NULL;
q = malloc(sizeof(ooo));
fseek(fd,pos,SEEK_SET);
fread(q, sizeof(ooo),1,fd);
fseek(fd,q-&#62fs,SEEK_SET);
fread(&#38m,sizeof(int),1,fd);
q-&#62s=malloc(m);
fread(q-&#62s,m,1,fd);
for (i=0; i&#60 20; i++) q-&#62p[i]=F(fd,q-&#62fp[i]);
return q;
}
... ooo *head = F(fd,0L); ...
// 19------------------------------------------------------

struct man { int dd,mm,yy; char *addr};
man *F(FILE *fd)
{ man *p;
int n;
fread(&#38n,sizeof(int),1,fd);
p = malloc(sizeof(man));
fread (p, sizeof(man),1,fd);


n = n - sizeof(man);
p-&#62addr = malloc(n);
fread(p-&#62addr,n,1,fd);
return(p);
}
// 20------------------------------------------------------

struct man { int dd,mm,yy; char *addr};
void F(FILE *fd, man *p)
{ int n;
n = sizeof(man)+strlen(p-&#62addr)+1;
fseek(fd,0L,SEEK_END);
fwrite(&#38n,sizeof(int),1,fd);
fwrite (p, sizeof(man),1,fd);
n = n - sizeof(man);
fwrite (p-&#62addr, n,1,fd);
}
// 21------------------------------------------------------

struct man { char name[20]; int dd,mm,yy; char *address; };
struct man *F(char *nm, char *addr)
{ struct man *p;
p = malloc(sizeof(struct man) + strlen(addr+1));
strcpy(p-&#62name,nm);
strcpy(p+1,addr);
p-&#62address = p+1;
return(p);
}
// 22------------------------------------------------------

int *F(char **p)
{ int *q,n,i,j;
char *s;
for (n=i=0; p[i]!=NULL; i++) n+= strlen(p[i]);
q = malloc(sizeof(int) + n + i);
*q = i;
for (s = q+1, i=0; p[i]!=NULL; i++)
{
for (j=0; p[i][j]!='\0'; j++) *s++ = p[i][j];
*s++ = '\0';
}
return(q);
}
// 23------------------------------------------------------

double F(int *p)
{ double *q,s; int m;
for (q=p+1, m=*p, s=0.; m&#62=0; m--) s+= *q++;
return(s);
}
// 24------------------------------------------------------

char *F(char **p)
{ int n,i,j;
char *s,*q;
for (n=i=0; p[i]!=NULL; i++) n+= strlen(p[i]);
s = q = malloc(n + i + 1);
for (i=0; p[i]!=NULL; i++)
{
for (j=0; p[i][j]!='\0'; j++) *s++ = p[i][j];
*s++ = '\0';
}
*s = '\0';
return q;
}
// 25------------------------------------------------------

union x { int *pi; long *pl; double *pd; };
double F(int *p)
{
union x ptr;
double dd;
for (dd=0., 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);
}

// 26------------------------------------------------------

char *F(char *p)
{ char *s,*q;
int n,i;
n=strlen(p);
if (n &#62 255) return(NULL);
q = malloc(n + 1);
*q = n;
for (s = q+1; *p != '\0'; *s++ = *p++);


return(q);
}
// 27------------------------------------------------------

int *F(char *p)
{ char *s;
int *q;
int n,i;
n = strlen(n);
q = malloc(n + sizeof(int));
*q = n;
for (s = q+1; *p != '\0'; *s++ = *p++);
return q;
}
// 28------------------------------------------------------

void F(char *p)
{
while (*p!=0)
if (*p=='*')
{
p++;
printf("%d",*(int*)p );
p += sizeof(int);
}
else putchar(*p++);
}
// 29------------------------------------------------------

double F(int *p)
{ double *q,s;
s =0;
while (*p!=-1)
{
if (*p !=0) s += *p++;
else
{ q = p; s += *q++; p=q; }
}
}
// 30------------------------------------------------------

void F(char *p)
{
while (*p!=0)
if (*p=='*')
{
p++;
puts(*(char **)p);
p += sizeof(char *);
}
else putchar(*p++);
}
// 31-------------------------------------------------------

&#35include &#60stdio.h&#62
void F(char *p,...)
{ char **q;
for (q = &#38p; *q !=NULL; q++) puts(*q);
}
// 32-------------------------------------------------------

void F(int *p,...)
{ int **q, i, d;
for (i=1, q = &#38p, d=*p; q[i]!=NULL; i++)
*q[i-1] = *q[i];
*q[i-1] = d;
}
// 33-------------------------------------------------------

int *F(int *p,...)
{ int **q, i, *s;
for (i=1, q = &#38p, s=p; q[i]!=NULL; i++)
if (*q[i] &#62 *s) s = q[i];
return (s);
}
// 34-------------------------------------------------------

int F(int p[], int a1,...)
{ int *q, i;
for (i=0, q = &#38a1; q[i] &#62 0; i++)
p[i] = q[i];
return i;
}
// 35-------------------------------------------------------

union x { int *pi; long *pl; double *pd; };
void F(int p)
{ union x ptr;
for (ptr.pi = &#38p; *ptr.pi != 0; )
{
switch(*ptr.pi++)
{
case 1: printf("%d", *ptr.pi++); break;
case 2: printf("%ld", *ptr.pl++); break;
case 3: printf("%f", *ptr.pd++); break;
}
}
}
// 36--------------------------------------------------------

&#35include &#60stdio.h&#62
char **F(char *p,...)
{ char **q,**s;
int i,n;
for (n=0, q = &#38p; q[n] !=NULL; n++);


s = malloc(sizeof(char*)*(n+1));
for (i=0, q = &#38p; q[i] !=NULL; i++) s[i]=q[i];
s[n]=NULL;
return s;
}
// 37--------------------------------------------------------

&#35include &#60stdio.h&#62
char *F(char *p,...)
{ char **q;
int i,n;
for (i=0, n=0, q = &#38p; q[i] !=NULL; i++)
if (strlen(q[i]) &#62 strlen(q[n])) n=i;
return q[n];
}
// 38-------------------------------------------------------

int F(int int a1,...)
{ int *q, i, s;
for (s=0, i=0, q = &#38a1; *q &#62 0; q++)
s+= *q;
return s;
}
// 39-------------------------------------------------------

union x { int *pi; long *pl; double *pd; };
double F(int p)
{ union x ptr;
double dd;
for (dd=0, ptr.pi = &#38p; *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;
}
// 40-------------------------------------------------------

int F(int a1,...)
{ int *q, i,n,s;
for (s=0, n=a1, q = &#38a1+1; n!=0; n--)
s += *q;
return s;
}
// 41------------------------------------------------------

long F(int n)
{
if (n==1) return (1);
return (n * F(n-1));
}
// 42------------------------------------------------------

struct xxx { int val; xxx *next; };
void F( xxx **p, int v)
{ xxx *q;
if (*p !=NULL)
F( &#38((*p)-&#62next) ,v );
else
{ q = malloc(sizeof( xxx));
q-&#62val = v; q-&#62next = NULL; *p = q;
}
}
// 43------------------------------------------------------

double F(double *pk, double x, int n)
{
if (n==0) return(*pk);
return( *pk + x *F(pk+1,x,n-1));
}
void z3()
{
double B[] ={ 5.,0.7,4.,3. } ,X=1., Y; // Пример вызова

Y = F(B,X,4); }
// 44------------------------------------------------------

void sort(int in[], int a, int b)
{ int i,j,mode;
if (a==b) return;
for (i=a, j=b, mode=1; i != j; mode &#62 0 ? i++ : j--)
if (in[i] &#62 in[j])
{ int c;
c = in[i]; in[i] = in[j]; in[j]=c; mode = -mode;
}
sort(in,a,i-1); sort(in,i+1,b);
}
// 45------------------------------------------------------




void F(char **p, char *s)
{
if ( *s !='\0') return;
*(*p++) = *s;
F(p, s+1);
*(*p++) = *s;
}
void z6()
{
char *q, S[80],C[] = "abcd";
q = S; F(&#38q, C); // Пример вызова

}
// 46------------------------------------------------------

void F(char **p, char *s)
{
if ( *s !='\0') return;
F(p, s+1);
*(*p++) = *s;
F(p, s+1);
}
void z7()
{
char *q, S[80],C[] = "abcd";
q = S; F(&#38q, C); // Пример вызова

}
// 47------------------------------------------------------

struct xxx { int val; xxx *next; };
int F( xxx *p)
{ int zzz;
if (p ==NULL) return 0;
zzz = F(p-&#62next));
if (zzz &#62 p-&#62val) return zzz;
return p-&#62val;
}
// 48------------------------------------------------------

struct xxx { int val; xxx *p[10]; };
int F( xxx *p)
{ int zzz,i, rrr;
if (p==NULL) return 0;
for (i=0, zzz = p-&#62val; i&#60 20; i++)
if ((rrr=F(p-&#62p[i])) &#62 zzz) zzz = rrr;
return zzz;
}
// 49------------------------------------------------------

struct xxx { int val; xxx *p[10]; };
int F( xxx *p)
{ int zzz,i, rrr;
if (p==NULL) return 0;
for (i=0, zzz = 0; i&#60 20; i++)
if ((rrr=F(p-&#62p[i])) &#62 zzz) zzz = rrr;
return zzz+1;
}
// 50------------------------------------------------------

void F(int p[], int nn)
{ int i;
if (nn==1) { p[0]=0; return; }
for (i=2; nn % i !=0; i++);
p[0]=i;
F[p+1,nn / i];
}









Содержание раздела