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

         

Вопросы без ответов


Определить значения переменных после выполнения действий.


//------------------------------------------------------bk13-01.cpp


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


int i1 = 0xFFFF; i1 ++;
//------------------------------------------------- 2


unsigned u1,u2,u; u1 = 5; u2 = -1; u=0; if (u1 &#62 u2) u++;
//------------------------------------------------- 3


int i1 = 0x01FF; char c; c = i1; i1 = c;
//------------------------------------------------- 4


int i1 = 0x01FF;
unsigned char c; c = i1; i1 = c;
//------------------------------------------------- 5


double d1,d2,d3;
d1 = 2.56; d2 = (int)d1 + 1.5;
d3 = (int)(d1 + 1.5);
//------------------------------------------------- 6


double d1 = 2.56; int i; i = (d1 - (int)d1) * 10;
//------------------------------------------------- 7


int i1=20000,i2=20000,s ; // sizeof(int) равен 2


long s1,s2;
s1 = i1 + i2; s2 = (long)i1 + i2;
if (s1 == s2) s=0; else s=1;
//------------------------------------------------- 8


i=0; if (i++) i++;
//------------------------------------------------- 9


i=0; if (++i) i++;
//------------------------------------------------ 10




m = a &#62 b ? a : b;
//------------------------------------------------ 11


m = (a * b) &#62 0;
//------------------------------------------------ 12


m = a &#62 0 ? a : -a;


Определить значения переменных после выполнения
операторов (по умолчанию все переменные - int) .


//------------------------------------------------------bk14-01.cpp

for (i=0; i&#60 20; I++);
//------------------------------------------------- 2

for (i=0,j=20; i&#60j; i++, j--);
//------------------------------------------------- 3

for (n=16,i=0; n!=1; i++, n/=2);
//------------------------------------------------- 4

for (i=0; 0; i++);
//------------------------------------------------- 5

for (i=0, d=0; i&#60 10; i++, d =!d);
//------------------------------------------------- 6

for (i=0; i&#62=0; i++);
//------------------------------------------------- 7

i=5; if (i) i++;
//------------------------------------------------- 8

for (i=1,s=1; i&#60=5; i++) s=s*i;
//------------------------------------------------- 9

for (i=1,s=0; i&#60=5; i++) s=s+i;
//------------------------------------------------ 10

for (i=0; 1; i++) { if (i==20) break; }
//------------------------------------------------ 11

for (i=0, n=0; i&#60 10; i++)
{ if (i &#62 5) continue;
n++;
}
//------------------------------------------------ 12

a = 5; b = 3; c = 1;
switch ((a &#62 b) * 2 + (b &#62 c))
{
case 0: n = c; break;
case 1: n = b; break;
case 2: n = c &#62 a ? c : a; break;
case 3: n = a; break;
}


Содержательно сформулировать результат выполнения фрагмента программы примерно в таком виде: " Последовательный просмотр элементов
массива и поиск нулевого" .


//------------------------------------------------------bk15-02.cpp

int d,s,i,A[20]; char c;
//------------------------------------------------- 1

for (s=0,i=0; i&#60 20; i++) s+=A[i];
//------------------------------------------------- 2

for (d=A[0], i=1; i&#60 20; i++) if (d &#62 A[i]) d=A[i];
//------------------------------------------------- 3

for (i=0; i&#60 20 &#38&#38 A[i] !=0; i++);
if (i!=20) A[i]=10000;
//------------------------------------------------- 4

for (d=0, i=0; i&#62=0; i==19 ? d=!d : 1 , d ? i-- : i++)
{ A[i]; }
//------------------------------------------------- 5

for (i=0, s=0; i&#60 20; i++)
{ if (A[i]==0) continue; s++; }
//------------------------------------------------- 6

for (i=0; i&#60 20; i++)
if (A[i]==0) { A[i]=10000; break; }
//------------------------------------------------- 7

for (i=s=0; i&#60 20; A[i] &#62=0 ? s++ : s--, i++);
//------------------------------------------------- 8

for (i=s=0; i&#60 20; i++) s+= A[i] &#62 0;
//------------------------------------------------- 9

for (s=A[19], i=19; i!=0; i--) A[i]=A[i-1];
A[0]=s;
//------------------------------------------------ 10

d = -1;
switch (c)
{
case '9': d++;
case '8': d++;
// ...

case '0': d++;
};


Определите " смысл" приведенных ниже фрагментов программ и сформулируйте его в виде одной фразы, например : " программа находит максимальное значение из элементов
массива A" .


//------------------------------------------------------bk23-01.cpp

// Дальше некуда

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

cin &#62&#62 a &#62&#62 b;
c=a; a=b; b=c;
//--------------------------------------------------------2

c= A[i]; A[i]=A[i+1]; A[i+1]=c;
//--------------------------------------------------------3

cin &#62&#62 a &#62&#62 b;
if (a &#60 b) c = b; else c = a;
//--------------------------------------------------------4

cin &#62&#62 a &#62&#62 b;
c = a; if (a &#62 b) c = b;
//--------------------------------------------------------5

if (a &#60 0) a = -a;
//--------------------------------------------------------6

if (a &#62 0 ) a = a + 1; else a = a - 1;
//--------------------------------------------------------7

for (i=1; i&#60 10; i++) ...
// Переменная - минимум/максимум

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

for (i=0,s=0; i&#60 10; i++)
if (A[i]&#62s) s=A[i];
//---------------------------------------------------------9

for (i=1,k=0; i&#60 10; i++)
if (A[i]&#62A[k]) k=i;
//--------------------------------------------------------- 10

for (i=0,k=-1; i&#60 10; i++)
{ if (A[i]&#60 0) continue;
if (k==-1) k=i;
else
if (A[i]&#60A[k]) k=i;
}
//--------------------------------------------------------- 11

for (i=0,k=-1; i&#60 10; i++)
{ if (A[i]&#60 0) continue;
if (k==-1 || A[i]&#60A[k]) k=i;
}
// Переменная - счетчик

//---------------------------------------------------------1 2

for (i=0,s=0; i&#60 10; i++)
if (A[i]&#62 0) s++;
//--------------------------------------------------------- 13

for (i=1,s=0; i&#60 10; i++)
if (A[i]&#62 0 &#38&#38 A[i-1]&#60 0) s++;
//---------------------------------------------------------14


Содержательно сформулировать результат выполнения функции, примерно в таком виде: "Функция находит в массиве минимальный элемент и возвращает в качестве результата его
индекс". Для этого необходимо формальную запись алгоритма перевести в словесное описание, а затем попытаться сформулировать результат. Если это не получается, то же самое можно попытаться проделать по шагам, либо по нисходящей, либо по восходящей цепочке конструкций языка: перевести конструкцию в словесное описание, сформулировать результат или алгоритм ее выполнения, затем то же самое сделать с учетом вложенной или объемлющей конструкции. То есть использовать ту же технологию структурного проектирования с точностью до наоборот.


//------------------------------------------------------bk32-04.cpp

int F1(int c[], int n)
{ int s,i;
for (s=0, i=0; i&#60n; i++) s +=c[i]; return s; }
//------------------------------------------------ 2

int F2(int c[], int n)
{ int m,i,k;
for (m=c[0],i=1,k=0; i&#60n; i++)
if (c[i] &#62 m) { m=c[i]; k=i;}
return k; }
//------------------------------------------------ 3

int F3(int c[], int n)
{ int i,j;
for (i=0; i&#60n-1; i++)
for (j=i+1; j&#60n; j++)
if (c[i]==c[j]) return i;
return -1; }
//------------------------------------------------ 4

int F4(int n)
{ int k,m;
for (k=0, m=1; m &#60= n; k++, m = m * 2);
return k-1; }
//------------------------------------------------ 5

void F5(int c[], int n)
{ int i,j,k;
for (i=0,j=n-1; i &#60 j; i++,j--)
{ k = c[i]; c[i] = c[j]; c[j] = k; }
}
//------------------------------------------------ 6

int F6(int c[], int n)
{ int i,j,k1,k2;
for (i=0; i&#60n; i++)
{
for (j=k1=k2=0; j&#60n; j++)
if (c[i] != c[j])
{ if (c[i] &#60 c[j]) k1++; else k2++; }
if (k1 == k2) return i;
}
return -1; }
//------------------------------------------------ 7

int F7(int c[], int n)
{ int i,j,m,s;
for (s=0, i=0; i &#60 n-1; i++)
{
for (j=i+1, m=0; j&#60n; j++)
if (c[i]==c[j]) m++;
if (m &#62 s) s = m;
}
return s; }
//------------------------------------------------ 8

int F8(int c[], int n)
{ int i,j,k,m;
for (i=k=m=0; i &#60 n-1; i++)
if (c[i] &#60 c[i+1])
k++;
else
{
if (k &#62 m) m=k;
k=0;
}
return m; }
//------------------------------------------------ 9

int F9(int n)
{ int i,k, c[6];
for (i=0; n !=0; i++, n /=10) c[i]=n % 10;
for( k=0; k &#60 i; k++) n = n *10 + c[k];
return n; }
//------------------------------------------------ 10

int F10(int n)
{ int m,k;
for (m=0; n!=0; n /=10)
if ((k = n % 10) &#62 m) m = k;
return m; }



Определить общий вид степенного ряда, вычисляемого в данной функции .



//------------------------------------------------------bk33-05.cpp

double sum(double x,double eps)
{
double s,sn; int n;
for (s=0, sn = 1, n=1; fabs(sn) &#62 eps; n++)
{ s += sn;
sn= - sn * x / n;
}
return s; }
//-----------------------------------------------2

for (s=0, sn = x, n=1; fabs(sn) &#62 eps; n++)
{ s += sn;
sn= - sn * x / n;
}
//-----------------------------------------------3

for (s=0, sn = x; n=1; fabs(sn) &#62 eps; n+=2)
{ s += sn;
sn= sn * x * x / (n*(n+1) );
}
//-----------------------------------------------4

for (s=0, sn = x, n=1; fabs(sn) &#62 eps; n+=2)
{ s += sn;
sn= sn * x / (n *(n+1) );
}
//-----------------------------------------------5

for (s=0, sn = x, n=1; fabs(sn) &#62 eps; n++)
{ s += sn;
sn= sn * x * (2*n) / (2*n-1);
}
//-----------------------------------------------6

for (s=0, sn = x, n=1; fabs(sn) &#62 eps; n+=2)
{ s += sn;
sn= sn * x *x * n / (n+1);
}
//-----------------------------------------------7

for (s=0, sn = x, n=1; fabs(sn) &#62 eps; n++)
{ s += sn;
sn= sn * x * x * (2*n-1) / (2*n+1);
}
//-----------------------------------------------8

for (s=0, sn = x, n=2; fabs(sn) &#62 eps; n+=2)
{ s += sn;
sn= sn * x *x * (n -1) / (n+1);
}
//-----------------------------------------------9

for (s=0, sn = 1, n=1; fabs(sn) &#62 eps; n++)
{ s += sn;
int nn = 2*n-2; if (nn==0) nn=1;
sn= sn * x * x * nn / (2*n);
}
//-----------------------------------------------10

for (s=0, sn = 1, n=1; fabs(sn) &#62 eps; n+=2)
{ s += sn;
int nn = n-1; if (nn==0) nn=1;
sn= sn * x *x * nn / (n+1);
}




//------------------------------------------------------bk34-13.cpp

void F1(char c[])
{ int i,j;
for (i=0; c[i] !='\0'; i++);
for (j=0,i--; i&#62j; i--,j++)
{ char s; s=c[i]; c[i]=c[j]; c[j]=s; }
}
//------------------------------------------------- 2

int F2(char s)
{ if (s &#62='0' &#38&#38 s &#60='9') return(s - '0');
else return(-1); }
//------------------------------------------------- 3

void F3(char c[])
{ int i;
for (i=0; c[i] !='\0'; i++)
if (c[i] &#62='a' &#38&#38 c[i] &#60='z')
c[i] += 'A' - 'a';
}
//------------------------------------------------- 4

int F4(char c[])
{ int i,old,nw;
for (i=0, old=0, nw=0; c[i] !='\0'; i++)
{
if (c[i]==' ') old = 0;
else { if (old==0) nw++; old=1; }
if (c[i]== '\0') break;
}
return nw; }
//------------------------------------------------- 5

void F5(char c[])
{ int i,j;
for (i=0, j=0; c[i] !='\0'; i++)
if (c[i] !=' ') c[j++] = c[i];
c[j] = '\0';
}
//------------------------------------------------- 6

void F6(char c[], int nn)
{ int k,mm;
for (mm=nn, k=1; mm !=0; mm /=10 ,k++);
for (c[k--]='\0'; k&#62=0; k--)
{ c[k]= nn % 10 + '0'; nn /=10; }
}
//------------------------------------------------- 7

int F7(char c[])
{ int i,s;
for (i=0; c[i] !='\0'; i++)
if (c[i] &#62='0' &#38&#38 c[i]&#60='7') break;
for (s=0; c[i] &#62='0' &#38&#38 c[i] &#60='7'; i++)
s = s * 8 + c[i] - '0';
return s; }
//------------------------------------------------- 8

int F8(char c[])
{ int n,k,ns;
for (n=0,ns=0; c[n] !='\0'; n++)
{
for (k=0; n-k !=0 &#38&#38 c[n+k] !='\0'; k++)
if (c[n-k] != c[n+k]) break;
if (k &#62=3) ns++;
}
return ns; }
//------------------------------------------------- 9

int F9(char c1[],char c2[])
{ int i,j;
for (i=0; c1[i] !='\0'; i++)
{
for (j=0; c2[j] !='\0'; j++)
if (c1[i+j] != c2[j]) break;
if (c2[j] =='\0') return i;
}
return -1;}
//------------------------------------------------ 10

char F10(char c[])
{ char m,z; int n,s,i;
for (s=0,m='A'; m &#60='Z'; m++)
{
for (n=0, i=0; c[i] !='\0'; i++)
if (c[i]==m) n++;
if (n &#62 s) { z=m; s=n; }
}
return z; }
//------------------------------------------------ 11

void F11(char c[], double x)
{ int i;
for (c[0]='.',i=1; i&#60 6; i++)
{
x *= 10.; c[i]=(int)x + '0'; x -= (int)x;
}
c[i]='\0'; }
//------------------------------------------------ 12

int F12(char c[])
{
for (int i=0; c[i]!=0; i++)
{
if (c[i]==' ') continue;
for (int j=i+1; c[j]==c[i]; j++);
for (; c[j]!=0; j++)
{
for (int k=0; i+k&#60j &#38&#38 c[i+k]==c[j+k]; k++);
if (k&#62=4) return i;
}
}
}




По тексту программы определите
алгоритм сортировки.


//------------------------------------------------------bk35-05.cpp

void F1(int in[],int n)
{ int i,j,k,c;
for (i=1; i&#60n; i++)
{ for (k=i; k !=0; k--)
{ if (in[k] &#62 in[k-1]) break;
c=in[k]; in[k]=in[k-1]; in[k-1]=c;
}
} }
//------------------------------------------------- 2

void F2(int in[],int out[],int n)
{ int i,j ,cnt;
for (i=0; i&#60 n; i++)
{
for ( cnt=0,j=0; j&#60n; j++)
if (in[j] &#62 in[i]) cnt++;
else
if (in[j]==in[i] &#38&#38 j&#62i) cnt++;
out[cnt]=in[i];
} }
//------------------------------------------------- 3

void F3(int in[],int n)
{ int a,b,dd,i,lasta,lastb,swap;
for (a=lasta=0, b=lastb=n, dd=1; a &#60 b;
dd = !dd, a=lasta, b=lastb)
{
if (dd)
{
for (i=a,lastb=a; i&#60b; i++)
if (in[i] &#62 in[i+1])
{ lastb = i;
swap = in[i]; in[i]=in[i+1]; in[i+1]=swap;
}
}
else
{
for (i=b,lasta=b; i&#62a; i--)
if (in[i-1] &#62 in[i])
{ lasta = i;
swap = in[i]; in[i]=in[i-1]; in[i-1]=swap;
} } } }
//------------------------------------------------- 4

int find(int out[],int n, int val);
// Двоичный или линейный поиск расположения значения val

// в массиве out[n]

void F4(in,n)
int in[],n;
{
int i,j,k;
for (i=1; i&#60n; i++)
{ int c; c = in[i]; k = find(in,i,c);
for (j=i; j!=k; j--) in[j] = in[j-1];
in[k] = c; }
}
//------------------------------------------------- 5

void F5(int in[], int n)
{ int i,j,c,k;
for (i=0; i &#60 n-1; i++)
{
for (j=i+1,c=in[i],k=i; j&#60n; j++)
if (in[j] &#62 c) { c = in[j]; k=j; }
in[k] = in[i]; in[i] = c;
} }
//------------------------------------------------- 6

&#35define MAXINT 0x7FFF
void F6(int in[], int n, int v0[], int v1[])
{
int m,i,max,i0,i1;
for (i=0, max=0; i&#60n; i++)
if (in[i] &#62 max) max=in[i];
for (m=1; m &#60=max; m &#60&#60=1);
for (m &#62&#62=1; m !=0; m &#62&#62=1)
{
for (i0=i1=0; i0+i1 &#60 n; )
if ((in[i0+i1] &#38 m) ==0)
v0[i0] = in[i0+i1], i0++;


Дайте определение нестандартным операциям со стеком и очередью,
представленным функциями.


//------------------------------------------------------bk36-04.cpp

int sp, LIFO[100];
int lst,fst,FIFO[100];
//------------------------------------------------- 1

void F1()
{ int c; if (sp &#60 1) return;
c = LIFO[sp]; LIFO[sp]=LIFO[sp-1]; LIFO[sp-1]=c;
}
//------------------------------------------------- 2

int F2(int n)
{ int v,i;
if (sp &#60 n) return (0);
v = LIFO[sp-n];
for (i=sp-n; i&#60sp; i++) LIFO[i]=LIFO[i+1];
sp--; return (v);}
//------------------------------------------------- 3

void F3(){ LIFO[sp+1]=LIFO[sp]; sp++; }
//------------------------------------------------- 4

int F4(int n)
{ int v,i1,i2;
i1 = (fst+n) %100;
v = FIFO[i1];
for (; i1!=lst; i1 = i2)
{
i2 = (i1 + 1) % 100;
FIFO[i1]=FIFO[i2];
}
lst = --lst % 100;
return(v);}
//------------------------------------------------- 5

void F5()
{ int n;
if (fst==lst) return;
n = (lst-1) %100;
FIFO[lst]=FIFO[n];
lst = ++lst % 100;}





//------------------------------------------------------bk41-02.cpp

void F1(int *p1, int *p2)
{ int c;
c = *p1; *p1 = *p2; *p2 = c;
}
//------------------------------------------------------- 2

void F2(int *p, int *q, int n)
{
for (*q = *p++; n &#62 0; n--, p++)
if (*p &#62 *q) *q = *p;
}
//------------------------------------------------------- 3

int *F3(int *p, int n)
{ int *q;
for (q = p; n &#62 0; n--, p++)
if (*p &#62 *q) q = p;
return q;
}
//--- Указатели на строки (char*) ----------------------- 4

void F4(char *p)
{ char *q;
for (q=p; *q !='\0'; q++);
for (q--; p &#60 q; p++, q--)
{ char c; c = *p; *p = *q; *q = c; }
}
//------------------------------------------------------- 5

int F5(char *p)
{ int n;
for (n=0; *p !='\0'; p++, n++);
return n;
}
//------------------------------------------------------- 6

char *F6(char *p,char *q)
{ char *s1,*s2;
for (; *p!='\0'; p++)
{
for (s1=p, s2=q; *s2!='\0' &#38&#38 *s1==*s2; s1++,s2++);
if (*s2 == '\0') return p;
}
return NULL;
}
//------------------------------------------------------- 7

void F7(char *p, char *q)
{
for (; *p !='\0'; p++);
for (; *q !='\0'; *p++ = *q++);
*q = '\0';
}
//------------------------------------------------------- 8

int F8(char *p)
{ int n;
if (*p=='\0') return (0);
if (*p !=' ') n=1; else n=0;
for (p++; *p !='\0'; p++)
if (p[0] !=' ' &#38&#38 p[-1]==' ') n++;
return n; }
//------------------------------------------------------- 9

void F9(char *p)
{ char *q; int n;
for (n=0, q=p; *p !='\0'; p++)
{
if (*p !=' ')
{ n=0; *q++ = *p; }
else
{ n++; if (n==1) *q++ = *p; }
}
}
//------------------------------------------------------ 10

void F10(char *p)
{ char *q; int cm;
for (q=p,cm=0; *p !='\0'; p++)
{
if (p[0]=='*' &#38&#38 p[1]=='/') { cm--, p++; continue; }
if (p[0]=='/' &#38&#38 p[1]=='*') { cm++, p++; continue; }
if (cm==0) *q++ = *p;
}
*q=0;
}


Определить значения
переменных после выполнения действий .


//------------------------------------------------------bk42-01.cpp

union x // sizeof(int) = 2

{ // sizeof(long)= 4

char c[4];
int n[2];
unsigned char u[4];
long l;
}
UNI;
struct man
{
char name[20];
int dd,mm,yy;
char *zodiak;
}
A= { "Иванов",1,10,1969,"Весы" }, B[10], *p;
//------------------------------------------------------- 1

void F1() {
char c; int i;
for (i=0; i&#60 10; i++)
B[i].zodiak = "abcdefghij" + i;
c = B[1].zodiak[2]; }
//------------------------------------------------------- 2

void F2() {
char c; int i,j;
for (i=0; i&#60 10; i++)
{
for (j=0; j&#60 10; j++)
B[i].name[j] = 'a' + i + j;
B[i].name[j]='\0';
}
c = B[1].zodiak[2]; }
//------------------------------------------------------ 3

void F3() {
int i,n;
for (i=0; i&#60 10; i++)
B[i].dd = i;
for (p=B, n=5; n!=0; n--, p++)
n += p-&#62dd; }
//------------------------------------------------------ 4

void F4() {
char c; int i;
for (i=0; i&#60 10; i++)
B[i].zodiak = A.zodiak + i % 4;
c = B[5].zodiak[2]; }
//------------------------------------------------------ 5

void F5() {
int i,n; char *p;
for (i=0; i&#60 10; i++)
B[i].zodiak = "abcdefghij" + i;
for (n=0, p=B[6].zodiak; *p !='\0'; p++, n++); }
//----------------------------------------------------- 6

void F6() {
long s; int i;
for (i=0; i&#60 4; i++) UNI.c[i]='0'+i;
s = UNI.l; }
//----------------------------------------------------- 7

void F7() {
char z;
UNI.l = 0x00003130;
z = UNI.c[1]; }
//----------------------------------------------------- 8

void F8() {
long s; char z;
UNI.l = 0x0000FFFF;
z = UNI.c[1]; UNI.c[1]=UNI.c[2]; UNI.c[2]=z;
s = UNI.l; }
//----------------------------------------------------- 9

void F9() {
long s;
UNI.l = 0x0001FFFF;
UNI.n[0] &#62&#62=2;
s = UNI.l; }
//---------------------------------------------------- 10

void F10() {
long s;
UNI.l = 0x0001FFFF;
UNI.c[1] &#60&#60=2;
s = UNI.l; }
//---------------------------------------------------- 11

void F11() {
long s;
UNI.l = 0x0001FFFF;
UNI.u[1] &#62&#62=2;
s = UNI.l; }
//---------------------------------------------------- 12

void F12() {
long s; int i,m, cr;
UNI.l = 0x00010000;
for (i=0; i&#60 4; i++) UNI.c[i] = ~UNI.c[i];
for (cr=1, i=0; i&#60 4; i++)
{
m = UNI.c[i] + cr;
UNI.c[i] = m;
cr = (m &#38 0x100) !=0;
}
s = UNI.l; }


Определите значения
переменных после выполнения действий .


//------------------------------------------------------bk43-01.cpp

&#35include &#60stdio.h&#62
struct man1
{
char name[20];
int dd,mm,yy;
char *zodiak;
struct man1 *next;
}
A1= {"Петров",1,10,1969,"Весы",NULL },
B1= {"Сидоров",8,9,1958,"Дева",&#38A1 },
*p1 = &#38B1;
void F1() {
char c1,c2,c3,c4;
c1 = A1.name[2]; c2 = B1.zodiak[3];
c3 = p1-&#62name[3]; c4 = p1-&#62next-&#62zodiak[1];
}
//------------------------------------------------------- 2

struct man2
{
char name[20];
char *zodiak;
struct man2 *next;
} C2[3] = {
{"Петров","Весы",NULL },
{"Сидоров","Дева",&#38C2[0] },
{"Иванов","Козерог",&#38C2[1] }
};
void F2() {
char c1,c2,c3,c4;
c1 = C2[0].name[2];
c2 = C2[1].zodiak[3];
c3 = C2[2].next-&#62name[3];
c4 = C2[2].next-&#62next-&#62zodiak[1];
}
//------------------------------------------------------- 3

struct tree3
{
int vv;
struct tree3 *l,*r;
}
A3 = { 1,NULL,NULL },
B3 = { 2,NULL,NULL },
C3 = { 3, &#38A3, &#38B3 },
D3 = { 4, &#38C3, NULL },
*p3 = &#38D3;
void F3() {
int i1,i2,i3,i4;
i1 =A3.vv; i2 = D3.l-&#62vv;
i3 =p3-&#62l-&#62r-&#62vv; i4 = p3-&#62vv;
}
//------------------------------------------------------- 4

struct tree4
{
int vv;
struct tree4 *l,*r;
}
F[4] =
{{ 1,NULL,NULL },
{ 2,NULL,NULL },
{ 3, &#38F[0], &#38F[1] },
{ 4, &#38F[2], NULL }};
void F4() {
int i1,i2,i3,i4;
i1 = F[0].vv; i2 = F[3].l-&#62vv;
i3 = F[3].l-&#62r-&#62vv; i4 = F[2].r-&#62vv;
}
//------------------------------------------------------- 5

struct list5
{
int vv;
struct list5 *pred,*next;
};
extern struct list5 C5,B5,A5;
struct list5 A5 = { 1, &#38C5, &#38B5 },
B5 = { 2, &#38A5, &#38C5 },
C5 = { 3, &#38B5, &#38A5 },
*p5 = &#38A5;
void F5() {
int i1,i2,i3,i4;
i1 = A5.next-&#62vv; i2 = p5-&#62next-&#62next-&#62vv;


Определить способ размещения последовательности
переменных в общей области памяти, которая читается или заполняется функцией (формат структуры данных).


//------------------------------------------------------bk44-03.cpp

struct man {char name[20]; int dd,mm,yy; char *addr; };
char *F1(char *p, char *nm, char *ad)
{ man *q =(man*)p;
strcpy(q-&#62name,nm);
strcpy((char*)q+1,ad);
q-&#62addr = (char*)q+1;
for (p=(char*)q+1; *p!=0; p++);
p++;
return p;}
//------------------------------------------------------ 2

struct man1 {char name[20]; int dd,mm,yy; char addr[]; };
char *F2(char *p, char *nm, char *ad)
{ man1 *q =(man1*)p;
strcpy(q-&#62name,nm);
strcpy(q-&#62addr,ad);
for (p=q-&#62addr; *p!=0; p++);
p++;
return p;}
//------------------------------------------------------ 3

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

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

char *F5(char *s, char *p[])
{ int i,j;
for (i=0; p[i]!=NULL; i++)
{
for (j=0; p[i][j]!='\0'; j++) *s++ = p[i][j];
*s++ = '\0';
}
*s = '\0';
return s;}
//------------------------------------------------------- 6

union x {int *pi; long *pl; double *pd;};
double F6(int *p)
{ union x 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;}
//------------------------------------------------------- 7

unsigned char *F7(unsigned char *s, char *p)
{ int n;
for (n=0; p[n] != '\0'; n++);
*((int*)s)++ = n;
for (; *p != '\0'; *s++ = *p++);
s++;
return s;}
//------------------------------------------------------- 8

int *F8(int *p, int n, double v[])


Для функции с
переменным количеством параметров определите их последовательность (формат) и приведите пример вызова.



//------------------------------------------------------bk45-03.cpp

void F1(char *p,...)
{ char **q;
for (q = &#38p; *q !=NULL; q++) cout &#60&#60 *q; }
//--------------------------------------------------------2

void F2(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;}
//--------------------------------------------------------3

int *F3(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;
}
//--------------------------------------------------------4

int F4(int p[], int a1,...)
{ int *q, i;
for (i=0, q = &#38a1; q[i] &#62 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 = &#38p; *ptr.pi != 0; )
{
switch(*ptr.pi++)
{
case 1: cout &#60&#60 *ptr.pi++; break;
case 2: cout &#60&#60 *ptr.pl++; break;
case 3: cout &#60&#60 *ptr.pd++; break;
}}}
//--------------------------------------------------------6

char **F6(char *p,...)
{ char **q,**s;
int i,n;
for (n=0, q = &#38p; q[n] !=NULL; n++);
s = new char*[n+1];
for (i=0, q = &#38p; 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 = &#38p; q[i] !=NULL; i++)
if (strlen(q[i]) &#62 strlen(q[n])) n=i;
return q[n];
}
//--------------------------------------------------------8

int F8(int a1,...)
{ int *q, i, s;
for (s=0, i=0, q = &#38a1; *q &#62 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 = &#38p; *ptr.pi != 0; )




//------------------------------------------------------bk47-04.cpp

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 &#62=0; n--) *q++ = *s++;
return p;
}
//------------------------------------------------------- 2

int *F2()
{ int n,i,*p;
cin &#62&#62 n;
p=new int[n+1];
for (p[0]=n, i=0; i&#60n; i++)
cin &#62&#62 p[i+1];
return p; }
//------------------------------------------------------- 3

int *F3()
{ int n,i,*p;
cin &#62&#62 n;
p=new int[n+1];
for (i=0; i&#60n; i++)
{ cin &#62&#62 p[i]; if (p[i]&# 60 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&#60n; 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 &#62&#62 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&#60n; i++)
{
for (k=0; k&#60m; 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; }


В первой половине заданий необходимо определить значения переменных после выполнения поразрядных
операций. Учтите, что заданные маски соответствуют восьмеричным или шестнадцатеричным цифрам.


//------------------------------------------------------bk48-06.cpp

int i,j; long l; char c; double d;
// Примечание: - sizeof(int) равен 2

// - sizeof(long) равен 4

// - "~" - операция побитовой инверсии

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

i = 0x5678;
l = (i &#38 ~0x00F0) | 0x0010;
c = (l &#62&#62 4) &#38 0xF + '0';
j = (i &#38 0xFF0F) | (~i &#38 0x00F0);
//------------------------------------------------ 2

i = 1; j = 2; c = 3;
l = (j &#62 i) + (j==c) &#60&#60 1 + (i !=c) &#60&#60 2;
//------------------------------------------------ 3

for (l=1,i=0; l &#62 0; l&#60&#60=1, i++);
//------------------------------------------------ 4

for (l=1,i=0; l !=0; l&#60&#60=1, i++);
//------------------------------------------------ 5

i = 1; j = 3; c = 2;
l = i + (j &#60&#60 4) + (c &#60&#60 8 );
c = i &#60&#60 8;
j = j &#60&#60 j;
//------------------------------------------------ 6

int F6(long n)
{ int i,s;
for (i=0,s=0; i &#60 sizeof(long) * 8; i++)
{ if (n &#38 1) s++; n &#62&#62=1; }
return s; }
//------------------------------------------------ 7

long F7(long n)
{ int i; long s;
for (i=s=0; i &#60 sizeof(long) * 8; i++)
{ s &#60&#60=1; s |= n &#38 1; n &#62&#62=1; }
return s; }
//------------------------------------------------ 8

long F8(long n, int m1, int m2)
{ long s,x; int i;
for (i=0,x=1,s=n; i &#60 sizeof(long)*8; i++)
{ if (i &#62=m1 &#38&#38 i &#60=m2) s |= x; x &#60&#60=1; }
return s; }
//------------------------------------------------ 9

int F9(char c[])
{ int i,s;
for (i=0; c[i] !='\0'; i++)
if (c[i] &#62='0' &#38&#38 c[i] &#60='7') break;
for (s=0; c[i] &#62='0' &#38&#38 c[i] &#60='7'; i++)
{ s &#60&#60=3; s |= c[i] &#38 0x7; }
return s; }
//------------------------------------------------ 10

void F10(char c[],long n)
{ int i;
i=sizeof(long)*8/3 +1;
for (c[i--]='\0'; i&#62=0; i--)
{ c[i] = n &#38 0x7 + '0'; n &#62&#62=3; }
}
//------------------------------------------------ 11

// Операция "^" - ИСКЛЮЧАЮЩЕЕ ИЛИ

int F11(long n)
{ int i,m,k;
for (i=m=k=0; i &#60 sizeof(long) * 8; i++, n &#62&#62= 1)
if ((n &#38 1) ^ m)
{ k++; m =!m; }
return k; }
//------------------------------------------------ 12

int F12(long n)
{ int i,m,k;
for (i=m=k=0; i &#60 sizeof(long) * 8; i++, n &#62&#62= 1)
if (n &#38 1)
k++;
else
{ if (k &#62 m) m=k; k=0; }
return m; }




//------------------------------------------------------bk52-05.cpp

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] &#62 *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] &#62 *q) break;
for (n=i; p[n]!=NULL; n++);
for (; n &#62=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&#60n; 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])) &#62sz) { 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++]=&#38c[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 &#62=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 &#62= 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;




//------------------------------------------------------bk53-07.cpp

struct list
{
int val;
list *next,*pred;
};
//------------------------------------------------------- 1

int F1(list *p)
{ int n;
for (n=0; p!=NULL; p=p-&#62next, n++);
return(n);
}
//------------------------------------------------------- 2

list *F2(list * p h, int v)
{ struct list *q;
q = new list;
q-&#62val = v; q-&#62next = p h; p h = q;
return ph;
}
//------------------------------------------------------- 3

list *F3(list *p, int n)
{
for (; n!=0 &#38&#38 p!=NULL; n--, p=p-&#62next);
return p;
}
//------------------------------------------------------- 4

list *F4(list *p h, int v)
{ list *q ,*p;
q = new list;
q-&#62val = v; q-&#62next = NULL;
if (ph == NULL) return q;
for ( p=ph ; p -&#62next !=NULL; p = p-&#62next);
p -&#62next = q;
return ph;
}
//------------------------------------------------------- 5

list *F5(list *p h, int n)
{ list *q ,*pr,*p;
for ( p=ph,pr=NULL; n!=0 &#38&#38 p!=NULL; n--, pr=p, p =p-&#62next);
if (p==NULL) return ph;
if (pr==NULL) { q=ph; ph=ph-&#62next; }
else { q=p; pr-&#62next=p-&#62next; }
delete q;
return ph;
}
//------------------------------------------------------- 6

int F6(list *p)
{ int n; list *q;
if (p==NULL) return(0);
for (q = p, p = p-&#62next, n=1; p !=q; p=p-&#62next, n++);
return n;
}
//------------------------------------------------------- 7

list *F7(list *p, int v)
{ list *q;
q = new list;
q-&#62val = v; q-&#62next = q-&#62pred = q;
if (p == NULL) p = q;
else
{
q-&#62next = p; q-&#62pred = p-&#62pred;
p-&#62pred-&#62next = q; p-&#62pred = q; p=q;
}
return p;
}
//------------------------------------------------------- 8

list *F8(list *ph)
{ list *q, *tmp, **pp;
tmp = NULL;
while (ph !=NULL)
{
q = ph; ph = ph-&#62next;
for (pp = &#38tmp; *pp !=NULL &#38&#38 (*pp)-&#62val &#60 q-&#62val;
pp = &#38(*pp)-&#62next);




//------------------------------------------------------bk54-06.cpp

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

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;
}
}
//------------------------------------------------------ 3

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); }
//------------------------------------------------------ 4

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);
}
//------------------------------------------------------ 5

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

}
//------------------------------------------------------ 6

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

}
//------------------------------------------------------ 7

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;
}
//------------------------------------------------------ 8

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;
}
//------------------------------------------------------ 9

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;
}
//------------------------------------------------------ 10

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);
}





//------------------------------------------------------bk55-11.cpp

struct xxx { int v; xxx *p[4]; };
int F(xxx *q)
{
int i,n,m;
if (q==NULL) return 0;
for (n=F1(q-&#62p[0]),i=1; i&#60 4; i++)
if ((m=F(q-&#62p[i])) &#62n) n=m;
return n+1;
}
//-------------------------------------------------------2

struct xxx { int v; xxx *l,*r; };
int F( xxx *p)
{
if (p==NULL) return(0);
return (1 + F(p-&#62r) + F(p-&#62l));
}
//-------------------------------------------------------- 3

struct xxx { int v; xxx *p[4]; };
int F(xxx *q)
{
int i,n,m;
if (q==NULL) return 0;
for (n=q-&#62v,i=0; i&#60 4; i++)
if ((m=F(q-&#62p[i])) &#62n) n=m;
return n;
}
//-------------------------------------------------------- 4

void F(int a[], int n, int v)
{
if (a[n] ==-1) { a[n]=v; return; }
if (a[n]==v) return;
if (a[n] &#62v)
F(a,2*n,v);
else
F(a,2*n+1,v);
}
void z3() {
int B[256],i;
for (i=0; i&#60 256; i++) B[i]=-1;
F(B,1,5); F(B,1,3); } // Пример вызова

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

struct xxx { int v; xxx *p[4]; };
int F(xxx *q)
{
int i,n,m;
if (q==NULL) return 0;
for (n=q-&#62v,i=0; i&#60 4; i++)
n+=F(q-&#62p[i]);
return n;
}
//------------------------------------------------------- 6

struct xxx { int k; int v[10]; xxx *l,*r; };
int F(xxx *q)
{
int i,n,m;
if (q==NULL) return 0;
for (n=0,i=0; i&#60k; i++)
n+=q-&#62v[i]);
return n+F(q-&#62l)+F(q-&#62r);
}
//------------------------------------------------------- 7

struct xxx { int v; xxx *p[4]; };
int F(xxx *q)
{
int i,n,m;
if (q==NULL) return 0;
for (n=1,i=0; i&#60 4; i++)
n+=F(q-&#62p[i]);
return n;
}
//-------------------------------------------------------- 8

struct xxx { int v; xxx *l,*r; };
int F( xxx *p)
{
if (p==NULL) return(0);
int nr=F(p-&#62r)+1;
int nl=F(p-&#62l)+1;
return nr&#62nl ? nr : nl;
}
//------------------------------------------------------- 9

struct xxx { int v; xxx *p[4]; };
int F(xxx *q)
{
int i,n,m;
if (q==NULL) return -1;
if (q-&#62v &#62=0) return q-&#62v;
for (n=1,i=0; i&#60 4; i++)
if ((m=F(q-&#62p[i] )) !=-1) return m;;
return -1;
}


Примеры 1- 5 содержат итерационные циклы, используемые в приближенных вычислениях. Содержательно определить смысл алгоритма и назначение
указателя на функцию. В остальных примерах определить результат.


//------------------------------------------------------bk56-04.cpp

double F1(double a, double b, double (*pf)(double))
{ double m;
if ((*pf)(a) * (*pf)(b) &#62 0 )return(a);
while ( b-a &#62 0.0001 )
{
m = (b + a)/2;
if ((*pf)(a) * (*pf)(m) &#60 0) b=m; else a=m;
}
return a;
}
//------------------------------------------------------- 2

double F2(double x, double s0, double (*pf)(double,int))
{ double s; int n;
for (n=1, s=0.0; fabs(s0) &#62 0.0001; n++)
{ s += s0; s0 = s0 * (pf)(x,n); }
return s; }
double ff(double x, int n) { return( x/n); }
void main()
{ double x,y; y = F2(x, 1, ff); }
//------------------------------------------------------- 3

double F(double a, double b, double (*pf)(double))
{ double dd;
for (dd = 0.0001; b-a &#62 dd;)
if ((*pf)(a) &#62 (*pf)(b)) b -=dd; else a +=dd;
return a;
}
//------------------------------------------------------- 4

double F4(double x, double (*pf)(double))
{ double x1;
do {
x1 = x; x = (*pf)(x1) + x1;
if (fabs(x) &#62 fabs(x1)) return(0.0);
}
while (fabs(x1-x) &#62 0.0001);
return x;
}
//------------------------------------------------------- 5

double F5(double a, double b, int n, double(*pf)(double))
{ double s,h,x;
for (s=0., x=a, h = (b-a)/n; x &#60=b; x+=h)
s += (*pf)(x) * h;
return s;}
extern double sin(double);
void main() { cout &#60&#60 F5(0.,1.,40,sin)); }
//------------------------------------------------------- 6

void ( *P(void(*ff)(void)))(void) { return ff; }
void foo(void){ cout &#60&#60 "I'm foo" &#60&#60 endl; }
void main(){(*P(foo))();}
//------------------------------------------------------- 7

int ( *P(int(*ff)(int)))(int) { return ff; }
int inc(int n){ return n+1; }
void main(){ cout &#60&#60 (*P(inc))( 5);}
//------------------------------------------------------- 8

typedef void (*PF)(void);
PF P(PF ff) { return ff; }
void foo(void){ cout &#60&#60 "I'm foo" &#60&#60 endl; }
void main(){(*P(foo))();}
//------------------------------------------------------- 9

typedef int (*PF)(int);
PF P(PF ff) { return ff; }
int inc(int n){ return n+1; }
void main(){ cout &#60&#60 (*P(inc))( 7);}
//------------------------------------------------------ 10

double P(double(*ff [])(double) ,int n, double x )
{ return (*ff [n])(x); }
double(*FF [])(double) ={sin,cos,tan};
void main(){ cout &#60&#60 P( FF,1,0.5);}
//------------------------------------------------------ 11

typedef double(*PF)(double) ;
double P( PF ff [],int n, double x )
{ return (*ff [n])(x); }
PF FF []={sin,cos,tan};
void main(){ cout &#60&#60 P( FF,2,1.5);}




Определить вид итератора и структуру данных, с которой он работает


//------------------------------------------------------bk57-04.cpp

struct xxx { void *data; xxx *next; };
void F( xxx **p, void (*pf)(void*))
{
xxx *q;
for (; *p != NULL; p++)
for (q = *p; q != NULL; q = q-&#62next)
(*pf)(q-&#62data);
}
//-------------------------------------------------------- 2

struct xxx { void *data; xxx *next; };
struct sxxx { xxx *ph; sxxx *next; };
void F( sxxx *p, void (*pf)(void*))
{
xxx *q;
for (; p != NULL; p = p-&#62next)
for ( q = p-&#62ph; q!=NULL; q=q-&#62next)
(*pf)(q-&#62data);
}
//-------------------------------------------------------- 3

struct mxxx { void **data; mxxx *next; };
void F( mxxx *p, void (*pf)(void*))
{
void **q;
for (; p != NULL; p = p-&#62next)
for (q = p-&#62data; *q != NULL; q++)
(*pf)(*q);
}
//-------------------------------------------------------- 4

void F(void ***p, void (*pf)(void*))
{
void **q;
for (; *p != NULL; p++)
for (q = *p; *q != NULL; q++)
(*pf)(*q);
}
//------------------------------------------------------- 5

void F(void *p, int sz, int n, void (*pf)(void*))
{
char *q;
for (q = p; n &#62 0; n--, q+=sz) ( *pf)(q);
}
//-------------------------------------------------------- 6

struct xxx { void *data; xxx **link; };
void F( xxx *p, void (*pf)(void*))
{
xxx **q;
if (p==NULL) return;
(*pf)(p-&#62data);
for (q = p-&#62link; *q != NULL; q++)
F(*q,pf);
}
//-------------------------------------------------------- 7

struct xxx { void **data; xxx *r, *l; };
void F( xxx *p, void (*pf)(void*))
{
void **q;
if (p==NULL) return;
F(p-&#62r, pf);
for (q = p-&#62data; *q != NULL; q++)
(*pf)(*q);
F(p-&#62l, pf);
}
//------------------------------------------------------- 8

struct xxx { void *data; xxx *next; };
struct zzz { xxx *ph; zzz *r, *l; };
void F( zzz *p, void (*pf)(void*))
{
xxx *q;
if (p==NULL) return;
F(p-&#62r, pf);
for (q = p-&#62ph; q != NULL; q = q-&#62next)
(*pf)(q-&#62data);


Определить структуру данных в
двоичном файле произвольного доступа


//------------------------------------------------------bk59-13.cpp

struct man { int dd,mm,yy; };
man *F(int n, FILE *fd)
{ man *p;
p = new 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 = ( void*) new char[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 = new double[ n+1];
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 = new 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 = new 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 = ( void*) new char[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 = (void*)new char[sz];
fseek (fd, p0 + sizeof(long)*n, SEEK_SET);
fread (&#38p0, sizeof(long),1,fd);
fseek(fd, p0, SEEK_SET);




//------------------------------------------------------bk72-03.cpp

double &#38F1(double s[], int n)
{ int i,k; double d;
for (i=1, k=0, d=s[0]; i&#60n; i++)
if (s[i] &#62 d) { k=i; d=s[i]; }
return(s[k]);
}
//---------------------------------------------------- 2

void F2(char *&#38p, char *s)
{ p = new char[strlen(s)+1];
strcpy(p,s);
}
//---------------------------------------------------- 3

struct tree
{ int val;
tree *pr,*pl;
};
void F3(tree *&#38p, int v)
{
if (p==NULL)
{ p = new tree;
p-&#62pl = p-&#62pr=NULL;
p-&#62val = v; return;
}
if (p-&#62val = v) return;
if (p-&#62val &#62 v) F3(p-&#62pl,v); else F3(p-&#62pr,v);
}
//------------------------------------------------------

// Определить значения переменных после выполнения действий

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

int INC4(int &#38x)
{ x++; return(x+1); }
void main()
{ int x,y,z; x = 5; y = INC4(x);
z = INC4(INC4(x)); }
//----------------------------------------------------- 5

int &#38INC5(int &#38x)
{ x++; return(x); }
void main()
{ int x,y,z;
x = 5; y = INC5(x); z = INC5(INC5(x)); }
//----------------------------------------------------- 6

int *INC6(int &#38x)
{ x++; return(&#38x); }
void main()
{ int x,y,z; x = 5; y = *INC6(x);
z = *INC6(*INC6(x)); }
//----------------------------------------------------- 7

int INC7(int x)
{ x++; return(x+1); }
void main()
{ int x,y,z; x = 5; y = INC7(x);
z = INC7(INC7(x)); }
//----------------------------------------------------- 8

struct integer
{ int val;
friend integer INC8(integer);
integer INC9();
integer &#38INC10();
integer *INC11();
};
integer INC8(integer src)
{ src.val++; return(src); }
void main()
{ integer x = {5} ,y = {0}, z = {0};
y = INC8(x); z = INC8(INC8(x)); }
//----------------------------------------------------- 9

integer integer::INC9()
{ integer t = *this;
t.val++;
return(t);
}
void main()
{ integer x = {5}, y = {0}, z = {0};
y = x.INC9(); z = x.INC9().INC9(); }
//---------------------------------------------------- 10

integer &#38integer::INC10()
{ val++;
return(*this);
}
void main()
{ integer x = {5}, y = {0}, z= {0};
y = x.INC10(); z = x.INC10().INC10(); }
//---------------------------------------------------- 11

integer *integer::INC11()
{ val++;
return(this);
}
void main()
{ integer x = {5}, y ={0}, z ={0};
y = *x.INC11(); z = *(x.INC11()-&#62INC11()); }


Определите значения элементов данных объектов после выполнения переопределенных
операций .


//------------------------------------------------------bk73-14.cpp

&#35include &#60stdio.h&#62
&#35include &#60string.h&#62
class integ1
{
int val;
public: integ1 operator+(integ1);
integ1 operator+(int);
integ1 (int v0) { val = v0; }
};
integ1 integ1::operator+(integ1 two)
{ integ1 res = *this;
res.val += two.val;
return(res);
}
integ1 integ1::operator+(int two)
{ integ1 res = *this;
res.val += two;
return(res);
}
void main()
{integ1 x(5),y(0), z(0); y = x + 5; z = x + y; }
//------------------------------------------------------- 2

class integ2
{
int val;
public: integ2 &#38operator+(integ2 &#38);
integ2 &#38operator+(int &#38);
integ2 (int v0) { val = v0; }
};
integ2 &#38integ2::operator+(integ2 &#38two)
{
val += two.val;
return(*this);
}
integ2 &#38integ2::operator+(int &#38two)
{
val += two;
return(*this);
}
void main()
{ integ2 x(5),y(0), z(0); y = x + 5; z = x + y; }
//------------------------------------------------------- 3

class integ3
{
int val;
public:
integ3 &#38operator+(integ3 &#38);
integ3 operator+(int &#38);
integ3 (int v0) { val = v0; }
};
integ3 &#38integ3::operator+(integ3 &#38two)
{
two.val +=val;
return(*this);
}
integ3 integ3::operator+(int &#38two)
{ integ3 tmp = *this;
tmp.val += two;
return(tmp);
}
void main ()
{integ3 x(5),y(0), z(0); y = x + 5; z = x + y; }
//---------------------------------------------------------

class string
{
char *s;
public: string(char *);
string(string &#38);
string() { s=NULL; }
char operator[](int);
char &#38operator()(int);
string &#38operator=(int);
operator int ();
string &#38operator+(char);
string &#38operator+(char *);
string &#38operator+(string&#38);
};
string::string(string &#38src)
{ s = new char[strlen(src.s)+1]; strcpy(s,src.s); }
string::string(char *src)
{ s = new char [strlen(src)+1]; strcpy(s,src); }


Определить значения
переменных после выполнения действий .


//------------------------------------------------------bk75-01.cpp

&#35include &#60string.h&#62
class a
{ int x;
public: a() { x = 0; }
a(int n) { x = n; }
int get() { return(x); }
};
class b : public a
{
public:
int get() { return (a::get()+1); }
b(int n) : a(n+1) {}
};
void z1()
{ a a1(10); b b1(12);
int x = a1.get(); int y = b1.get();
}
//------------------------------------------------------- 2

class aa
{ int x;
public:
aa() { x = 0; }
aa(int n) { x = n; }
int inc() { return(++x); }
};
class bb: public aa
{
public: int inc() { int nn = aa::inc(); return (nn-1); }
bb(int n) : aa(n+1) {}
};
void z2()
{ aa a1(10); bb b1(12);
int x = a1.inc(); int y = b1.inc() + a1.inc();
}
//------------------------------------------------------- 3

class aaa
{ int x;
public: aaa() { x = 0; }
aaa(int n) { x = n; }
int inc() { return(++x); }
};
class bbb : public aaa
{
public: int inc() { int nn = aaa::inc(); return (nn-1); }
bbb(int n) : aaa(n+1) {}
};
void z3()
{ aaa a1(10); bbb b1(12);
aaa *pa = &#38b1; bbb *pb = &#38b1;
int x = a1.inc();
int y = b1.inc() + pa-&#62inc();
int z = pb-&#62inc();
}
//------------------------------------------------------ 4

class ax
{ int x;
public:
virtual int out() { return(x); }
ax(int n) { x = n; }
};
class bx : public ax
{
public: int out() { return (ax::out()+1); }
bx(int n) : ax(n) { }
};
class cx : public ax
{
public: cx(int n) : ax(n) { }
};
void z4()
{ ax A1(5);
bx B1(6);
cx C1(10);
ax *p[] = { &#38A1, &#38B1, &#38C1 };
int r1 = p[0]-&#62out() + p[1]-&#62out() + p[2]-&#62out();
int r2 = A1.out() + B1.out() + C1.out();
}
//------------------------------------------------------ 5

class ay
{
public: virtual int put()=0;
ay() {};
};
class integer : public ay
{ int val;
public: int put() { return(val); }
integer(int n) { val=n; }
};
class string : public ay
{
char *str;
public: int put() { return(strlen(str)); }
string(char *s) { str = s; }

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