Вопросы без ответов
Определить значения переменных после выполнения действий.
//------------------------------------------------------bk13-01.cpp
//------------------------------------------------- 1
int i1 = 0xFFFF; i1 ++;
//------------------------------------------------- 2
unsigned u1,u2,u; u1 = 5; u2 = -1; u=0; if (u1 > 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 > b ? a : b;
//------------------------------------------------ 11
m = (a * b) > 0;
//------------------------------------------------ 12
m = a > 0 ? a : -a;
Определить значения переменных после выполнения операторов (по умолчанию все переменные - int) .
//------------------------------------------------------bk14-01.cpp
for (i=0; i< 20; I++);
//------------------------------------------------- 2
for (i=0,j=20; i<j; 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< 10; i++, d =!d);
//------------------------------------------------- 6
for (i=0; i>=0; i++);
//------------------------------------------------- 7
i=5; if (i) i++;
//------------------------------------------------- 8
for (i=1,s=1; i<=5; i++) s=s*i;
//------------------------------------------------- 9
for (i=1,s=0; i<=5; i++) s=s+i;
//------------------------------------------------ 10
for (i=0; 1; i++) { if (i==20) break; }
//------------------------------------------------ 11
for (i=0, n=0; i< 10; i++)
{ if (i > 5) continue;
n++;
}
//------------------------------------------------ 12
a = 5; b = 3; c = 1;
switch ((a > b) * 2 + (b > c))
{
case 0: n = c; break;
case 1: n = b; break;
case 2: n = c > 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< 20; i++) s+=A[i];
//------------------------------------------------- 2
for (d=A[0], i=1; i< 20; i++) if (d > A[i]) d=A[i];
//------------------------------------------------- 3
for (i=0; i< 20 && A[i] !=0; i++);
if (i!=20) A[i]=10000;
//------------------------------------------------- 4
for (d=0, i=0; i>=0; i==19 ? d=!d : 1 , d ? i-- : i++)
{ A[i]; }
//------------------------------------------------- 5
for (i=0, s=0; i< 20; i++)
{ if (A[i]==0) continue; s++; }
//------------------------------------------------- 6
for (i=0; i< 20; i++)
if (A[i]==0) { A[i]=10000; break; }
//------------------------------------------------- 7
for (i=s=0; i< 20; A[i] >=0 ? s++ : s--, i++);
//------------------------------------------------- 8
for (i=s=0; i< 20; i++) s+= A[i] > 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 >> a >> b;
c=a; a=b; b=c;
//--------------------------------------------------------2
c= A[i]; A[i]=A[i+1]; A[i+1]=c;
//--------------------------------------------------------3
cin >> a >> b;
if (a < b) c = b; else c = a;
//--------------------------------------------------------4
cin >> a >> b;
c = a; if (a > b) c = b;
//--------------------------------------------------------5
if (a < 0) a = -a;
//--------------------------------------------------------6
if (a > 0 ) a = a + 1; else a = a - 1;
//--------------------------------------------------------7
for (i=1; i< 10; i++) ...
// Переменная - минимум/максимум
//---------------------------------------------------------8
for (i=0,s=0; i< 10; i++)
if (A[i]>s) s=A[i];
//---------------------------------------------------------9
for (i=1,k=0; i< 10; i++)
if (A[i]>A[k]) k=i;
//--------------------------------------------------------- 10
for (i=0,k=-1; i< 10; i++)
{ if (A[i]< 0) continue;
if (k==-1) k=i;
else
if (A[i]<A[k]) k=i;
}
//--------------------------------------------------------- 11
for (i=0,k=-1; i< 10; i++)
{ if (A[i]< 0) continue;
if (k==-1 || A[i]<A[k]) k=i;
}
// Переменная - счетчик
//---------------------------------------------------------1 2
for (i=0,s=0; i< 10; i++)
if (A[i]> 0) s++;
//--------------------------------------------------------- 13
for (i=1,s=0; i< 10; i++)
if (A[i]> 0 && A[i-1]< 0) s++;
//---------------------------------------------------------14
Содержательно сформулировать результат выполнения функции, примерно в таком виде: "Функция находит в массиве минимальный элемент и возвращает в качестве результата его индекс". Для этого необходимо формальную запись алгоритма перевести в словесное описание, а затем попытаться сформулировать результат. Если это не получается, то же самое можно попытаться проделать по шагам, либо по нисходящей, либо по восходящей цепочке конструкций языка: перевести конструкцию в словесное описание, сформулировать результат или алгоритм ее выполнения, затем то же самое сделать с учетом вложенной или объемлющей конструкции. То есть использовать ту же технологию структурного проектирования с точностью до наоборот.
//------------------------------------------------------bk32-04.cpp
int F1(int c[], int n)
{ int s,i;
for (s=0, i=0; i<n; 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<n; i++)
if (c[i] > m) { m=c[i]; k=i;}
return k; }
//------------------------------------------------ 3
int F3(int c[], int n)
{ int i,j;
for (i=0; i<n-1; i++)
for (j=i+1; j<n; j++)
if (c[i]==c[j]) return i;
return -1; }
//------------------------------------------------ 4
int F4(int n)
{ int k,m;
for (k=0, m=1; m <= 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 < 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<n; i++)
{
for (j=k1=k2=0; j<n; j++)
if (c[i] != c[j])
{ if (c[i] < 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 < n-1; i++)
{
for (j=i+1, m=0; j<n; j++)
if (c[i]==c[j]) m++;
if (m > s) s = m;
}
return s; }
//------------------------------------------------ 8
int F8(int c[], int n)
{ int i,j,k,m;
for (i=k=m=0; i < n-1; i++)
if (c[i] < c[i+1])
k++;
else
{
if (k > 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 < 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) > 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) > eps; n++)
{ s += sn;
sn= - sn * x / n;
}
return s; }
//-----------------------------------------------2
for (s=0, sn = x, n=1; fabs(sn) > eps; n++)
{ s += sn;
sn= - sn * x / n;
}
//-----------------------------------------------3
for (s=0, sn = x; n=1; fabs(sn) > eps; n+=2)
{ s += sn;
sn= sn * x * x / (n*(n+1) );
}
//-----------------------------------------------4
for (s=0, sn = x, n=1; fabs(sn) > eps; n+=2)
{ s += sn;
sn= sn * x / (n *(n+1) );
}
//-----------------------------------------------5
for (s=0, sn = x, n=1; fabs(sn) > eps; n++)
{ s += sn;
sn= sn * x * (2*n) / (2*n-1);
}
//-----------------------------------------------6
for (s=0, sn = x, n=1; fabs(sn) > eps; n+=2)
{ s += sn;
sn= sn * x *x * n / (n+1);
}
//-----------------------------------------------7
for (s=0, sn = x, n=1; fabs(sn) > eps; n++)
{ s += sn;
sn= sn * x * x * (2*n-1) / (2*n+1);
}
//-----------------------------------------------8
for (s=0, sn = x, n=2; fabs(sn) > eps; n+=2)
{ s += sn;
sn= sn * x *x * (n -1) / (n+1);
}
//-----------------------------------------------9
for (s=0, sn = 1, n=1; fabs(sn) > 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) > 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>j; i--,j++)
{ char s; s=c[i]; c[i]=c[j]; c[j]=s; }
}
//------------------------------------------------- 2
int F2(char s)
{ if (s >='0' && s <='9') return(s - '0');
else return(-1); }
//------------------------------------------------- 3
void F3(char c[])
{ int i;
for (i=0; c[i] !='\0'; i++)
if (c[i] >='a' && c[i] <='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>=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] >='0' && c[i]<='7') break;
for (s=0; c[i] >='0' && c[i] <='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 && c[n+k] !='\0'; k++)
if (c[n-k] != c[n+k]) break;
if (k >=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 <='Z'; m++)
{
for (n=0, i=0; c[i] !='\0'; i++)
if (c[i]==m) n++;
if (n > s) { z=m; s=n; }
}
return z; }
//------------------------------------------------ 11
void F11(char c[], double x)
{ int i;
for (c[0]='.',i=1; i< 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<j && c[i+k]==c[j+k]; k++);
if (k>=4) return i;
}
}
}
По тексту программы определите алгоритм сортировки.
//------------------------------------------------------bk35-05.cpp
void F1(int in[],int n)
{ int i,j,k,c;
for (i=1; i<n; i++)
{ for (k=i; k !=0; k--)
{ if (in[k] > 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< n; i++)
{
for ( cnt=0,j=0; j<n; j++)
if (in[j] > in[i]) cnt++;
else
if (in[j]==in[i] && j>i) 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 < b;
dd = !dd, a=lasta, b=lastb)
{
if (dd)
{
for (i=a,lastb=a; i<b; i++)
if (in[i] > in[i+1])
{ lastb = i;
swap = in[i]; in[i]=in[i+1]; in[i+1]=swap;
}
}
else
{
for (i=b,lasta=b; i>a; i--)
if (in[i-1] > 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<n; 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 < n-1; i++)
{
for (j=i+1,c=in[i],k=i; j<n; j++)
if (in[j] > c) { c = in[j]; k=j; }
in[k] = in[i]; in[i] = c;
} }
//------------------------------------------------- 6
#define MAXINT 0x7FFF
void F6(int in[], int n, int v0[], int v1[])
{
int m,i,max,i0,i1;
for (i=0, max=0; i<n; i++)
if (in[i] > max) max=in[i];
for (m=1; m <=max; m <<=1);
for (m >>=1; m !=0; m >>=1)
{
for (i0=i1=0; i0+i1 < n; )
if ((in[i0+i1] & 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 < 1) return;
c = LIFO[sp]; LIFO[sp]=LIFO[sp-1]; LIFO[sp-1]=c;
}
//------------------------------------------------- 2
int F2(int n)
{ int v,i;
if (sp < n) return (0);
v = LIFO[sp-n];
for (i=sp-n; i<sp; 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 > 0; n--, p++)
if (*p > *q) *q = *p;
}
//------------------------------------------------------- 3
int *F3(int *p, int n)
{ int *q;
for (q = p; n > 0; n--, p++)
if (*p > *q) q = p;
return q;
}
//--- Указатели на строки (char*) ----------------------- 4
void F4(char *p)
{ char *q;
for (q=p; *q !='\0'; q++);
for (q--; p < 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' && *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] !=' ' && 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]=='*' && p[1]=='/') { cm--, p++; continue; }
if (p[0]=='/' && 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< 10; i++)
B[i].zodiak = "abcdefghij" + i;
c = B[1].zodiak[2]; }
//------------------------------------------------------- 2
void F2() {
char c; int i,j;
for (i=0; i< 10; i++)
{
for (j=0; j< 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< 10; i++)
B[i].dd = i;
for (p=B, n=5; n!=0; n--, p++)
n += p->dd; }
//------------------------------------------------------ 4
void F4() {
char c; int i;
for (i=0; i< 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< 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< 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] >>=2;
s = UNI.l; }
//---------------------------------------------------- 10
void F10() {
long s;
UNI.l = 0x0001FFFF;
UNI.c[1] <<=2;
s = UNI.l; }
//---------------------------------------------------- 11
void F11() {
long s;
UNI.l = 0x0001FFFF;
UNI.u[1] >>=2;
s = UNI.l; }
//---------------------------------------------------- 12
void F12() {
long s; int i,m, cr;
UNI.l = 0x00010000;
for (i=0; i< 4; i++) UNI.c[i] = ~UNI.c[i];
for (cr=1, i=0; i< 4; i++)
{
m = UNI.c[i] + cr;
UNI.c[i] = m;
cr = (m & 0x100) !=0;
}
s = UNI.l; }
Определите значения переменных после выполнения действий .
//------------------------------------------------------bk43-01.cpp
#include <stdio.h>
struct man1
{
char name[20];
int dd,mm,yy;
char *zodiak;
struct man1 *next;
}
A1= {"Петров",1,10,1969,"Весы",NULL },
B1= {"Сидоров",8,9,1958,"Дева",&A1 },
*p1 = &B1;
void F1() {
char c1,c2,c3,c4;
c1 = A1.name[2]; c2 = B1.zodiak[3];
c3 = p1->name[3]; c4 = p1->next->zodiak[1];
}
//------------------------------------------------------- 2
struct man2
{
char name[20];
char *zodiak;
struct man2 *next;
} C2[3] = {
{"Петров","Весы",NULL },
{"Сидоров","Дева",&C2[0] },
{"Иванов","Козерог",&C2[1] }
};
void F2() {
char c1,c2,c3,c4;
c1 = C2[0].name[2];
c2 = C2[1].zodiak[3];
c3 = C2[2].next->name[3];
c4 = C2[2].next->next->zodiak[1];
}
//------------------------------------------------------- 3
struct tree3
{
int vv;
struct tree3 *l,*r;
}
A3 = { 1,NULL,NULL },
B3 = { 2,NULL,NULL },
C3 = { 3, &A3, &B3 },
D3 = { 4, &C3, NULL },
*p3 = &D3;
void F3() {
int i1,i2,i3,i4;
i1 =A3.vv; i2 = D3.l->vv;
i3 =p3->l->r->vv; i4 = p3->vv;
}
//------------------------------------------------------- 4
struct tree4
{
int vv;
struct tree4 *l,*r;
}
F[4] =
{{ 1,NULL,NULL },
{ 2,NULL,NULL },
{ 3, &F[0], &F[1] },
{ 4, &F[2], NULL }};
void F4() {
int i1,i2,i3,i4;
i1 = F[0].vv; i2 = F[3].l->vv;
i3 = F[3].l->r->vv; i4 = F[2].r->vv;
}
//------------------------------------------------------- 5
struct list5
{
int vv;
struct list5 *pred,*next;
};
extern struct list5 C5,B5,A5;
struct list5 A5 = { 1, &C5, &B5 },
B5 = { 2, &A5, &C5 },
C5 = { 3, &B5, &A5 },
*p5 = &A5;
void F5() {
int i1,i2,i3,i4;
i1 = A5.next->vv; i2 = p5->next->next->vv;
Определить способ размещения последовательности переменных в общей области памяти, которая читается или заполняется функцией (формат структуры данных).
//------------------------------------------------------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->name,nm);
strcpy((char*)q+1,ad);
q->addr = (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->name,nm);
strcpy(q->addr,ad);
for (p=q->addr; *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>=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 = &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; )
//------------------------------------------------------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 >=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]&# 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<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; }
В первой половине заданий необходимо определить значения переменных после выполнения поразрядных операций. Учтите, что заданные маски соответствуют восьмеричным или шестнадцатеричным цифрам.
//------------------------------------------------------bk48-06.cpp
int i,j; long l; char c; double d;
// Примечание: - sizeof(int) равен 2
// - sizeof(long) равен 4
// - "~" - операция побитовой инверсии
//------------------------------------------------ 1
i = 0x5678;
l = (i & ~0x00F0) | 0x0010;
c = (l >> 4) & 0xF + '0';
j = (i & 0xFF0F) | (~i & 0x00F0);
//------------------------------------------------ 2
i = 1; j = 2; c = 3;
l = (j > i) + (j==c) << 1 + (i !=c) << 2;
//------------------------------------------------ 3
for (l=1,i=0; l > 0; l<<=1, i++);
//------------------------------------------------ 4
for (l=1,i=0; l !=0; l<<=1, i++);
//------------------------------------------------ 5
i = 1; j = 3; c = 2;
l = i + (j << 4) + (c << 8 );
c = i << 8;
j = j << j;
//------------------------------------------------ 6
int F6(long n)
{ int i,s;
for (i=0,s=0; i < sizeof(long) * 8; i++)
{ if (n & 1) s++; n >>=1; }
return s; }
//------------------------------------------------ 7
long F7(long n)
{ int i; long s;
for (i=s=0; i < sizeof(long) * 8; i++)
{ s <<=1; s |= n & 1; n >>=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 < sizeof(long)*8; i++)
{ if (i >=m1 && i <=m2) s |= x; x <<=1; }
return s; }
//------------------------------------------------ 9
int F9(char c[])
{ int i,s;
for (i=0; c[i] !='\0'; i++)
if (c[i] >='0' && c[i] <='7') break;
for (s=0; c[i] >='0' && c[i] <='7'; i++)
{ s <<=3; s |= c[i] & 0x7; }
return s; }
//------------------------------------------------ 10
void F10(char c[],long n)
{ int i;
i=sizeof(long)*8/3 +1;
for (c[i--]='\0'; i>=0; i--)
{ c[i] = n & 0x7 + '0'; n >>=3; }
}
//------------------------------------------------ 11
// Операция "^" - ИСКЛЮЧАЮЩЕЕ ИЛИ
int F11(long n)
{ int i,m,k;
for (i=m=k=0; i < sizeof(long) * 8; i++, n >>= 1)
if ((n & 1) ^ m)
{ k++; m =!m; }
return k; }
//------------------------------------------------ 12
int F12(long n)
{ int i,m,k;
for (i=m=k=0; i < sizeof(long) * 8; i++, n >>= 1)
if (n & 1)
k++;
else
{ if (k > 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] > *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;
//------------------------------------------------------bk53-07.cpp
struct list
{
int val;
list *next,*pred;
};
//------------------------------------------------------- 1
int F1(list *p)
{ int n;
for (n=0; p!=NULL; p=p->next, n++);
return(n);
}
//------------------------------------------------------- 2
list *F2(list * p h, int v)
{ struct list *q;
q = new list;
q->val = v; q->next = p h; p h = q;
return ph;
}
//------------------------------------------------------- 3
list *F3(list *p, int n)
{
for (; n!=0 && p!=NULL; n--, p=p->next);
return p;
}
//------------------------------------------------------- 4
list *F4(list *p h, int v)
{ list *q ,*p;
q = new list;
q->val = v; q->next = NULL;
if (ph == NULL) return q;
for ( p=ph ; p ->next !=NULL; p = p->next);
p ->next = q;
return ph;
}
//------------------------------------------------------- 5
list *F5(list *p h, int n)
{ list *q ,*pr,*p;
for ( p=ph,pr=NULL; n!=0 && p!=NULL; n--, pr=p, p =p->next);
if (p==NULL) return ph;
if (pr==NULL) { q=ph; ph=ph->next; }
else { q=p; pr->next=p->next; }
delete q;
return ph;
}
//------------------------------------------------------- 6
int F6(list *p)
{ int n; list *q;
if (p==NULL) return(0);
for (q = p, p = p->next, n=1; p !=q; p=p->next, n++);
return n;
}
//------------------------------------------------------- 7
list *F7(list *p, int v)
{ list *q;
q = new list;
q->val = v; q->next = q->pred = q;
if (p == NULL) p = q;
else
{
q->next = p; q->pred = p->pred;
p->pred->next = q; p->pred = q; p=q;
}
return p;
}
//------------------------------------------------------- 8
list *F8(list *ph)
{ list *q, *tmp, **pp;
tmp = NULL;
while (ph !=NULL)
{
q = ph; ph = ph->next;
for (pp = &tmp; *pp !=NULL && (*pp)->val < q->val;
pp = &(*pp)->next);
//------------------------------------------------------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( &((*p)->next) ,v );
else
{ q = malloc(sizeof( xxx));
q->val = v; q->next = 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 > 0 ? i++ : j--)
if (in[i] > 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(&q,"abcd"); // Пример вызова
}
//------------------------------------------------------ 7
struct xxx { int val; xxx *next; };
int F( xxx *p)
{ int zzz;
if (p ==NULL) return 0;
zzz = F(p->next));
if (zzz > p->val) return zzz;
return p->val;
}
//------------------------------------------------------ 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->val; i< 20; i++)
if ((rrr=F(p->p[i])) > 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< 20; i++)
if ((rrr=F(p->p[i])) > 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->p[0]),i=1; i< 4; i++)
if ((m=F(q->p[i])) >n) 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->r) + F(p->l));
}
//-------------------------------------------------------- 3
struct xxx { int v; xxx *p[4]; };
int F(xxx *q)
{
int i,n,m;
if (q==NULL) return 0;
for (n=q->v,i=0; i< 4; i++)
if ((m=F(q->p[i])) >n) 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] >v)
F(a,2*n,v);
else
F(a,2*n+1,v);
}
void z3() {
int B[256],i;
for (i=0; i< 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->v,i=0; i< 4; i++)
n+=F(q->p[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<k; i++)
n+=q->v[i]);
return n+F(q->l)+F(q->r);
}
//------------------------------------------------------- 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< 4; i++)
n+=F(q->p[i]);
return n;
}
//-------------------------------------------------------- 8
struct xxx { int v; xxx *l,*r; };
int F( xxx *p)
{
if (p==NULL) return(0);
int nr=F(p->r)+1;
int nl=F(p->l)+1;
return nr>nl ? 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->v >=0) return q->v;
for (n=1,i=0; i< 4; i++)
if ((m=F(q->p[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) > 0 )return(a);
while ( b-a > 0.0001 )
{
m = (b + a)/2;
if ((*pf)(a) * (*pf)(m) < 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) > 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 > dd;)
if ((*pf)(a) > (*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) > fabs(x1)) return(0.0);
}
while (fabs(x1-x) > 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 <=b; x+=h)
s += (*pf)(x) * h;
return s;}
extern double sin(double);
void main() { cout << F5(0.,1.,40,sin)); }
//------------------------------------------------------- 6
void ( *P(void(*ff)(void)))(void) { return ff; }
void foo(void){ cout << "I'm foo" << endl; }
void main(){(*P(foo))();}
//------------------------------------------------------- 7
int ( *P(int(*ff)(int)))(int) { return ff; }
int inc(int n){ return n+1; }
void main(){ cout << (*P(inc))( 5);}
//------------------------------------------------------- 8
typedef void (*PF)(void);
PF P(PF ff) { return ff; }
void foo(void){ cout << "I'm foo" << 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 << (*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 << 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 << 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->next)
(*pf)(q->data);
}
//-------------------------------------------------------- 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->next)
for ( q = p->ph; q!=NULL; q=q->next)
(*pf)(q->data);
}
//-------------------------------------------------------- 3
struct mxxx { void **data; mxxx *next; };
void F( mxxx *p, void (*pf)(void*))
{
void **q;
for (; p != NULL; p = p->next)
for (q = p->data; *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 > 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->data);
for (q = p->link; *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->r, pf);
for (q = p->data; *q != NULL; q++)
(*pf)(*q);
F(p->l, 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->r, pf);
for (q = p->ph; q != NULL; q = q->next)
(*pf)(q->data);
Определить структуру данных в двоичном файле произвольного доступа
//------------------------------------------------------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(&n,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(&n,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
#define 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(&p0,sizeof(long),1,fd);
for (; p0!=FNULL && n!=0; n--, p0 = p->fnext)
{
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(&fp,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(&sz,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(&sz,sizeof(int),1,fd);
fread(&p0,sizeof(long),1,fd);
p = (void*)new char[sz];
fseek (fd, p0 + sizeof(long)*n, SEEK_SET);
fread (&p0, sizeof(long),1,fd);
fseek(fd, p0, SEEK_SET);
//------------------------------------------------------bk72-03.cpp
double &F1(double s[], int n)
{ int i,k; double d;
for (i=1, k=0, d=s[0]; i<n; i++)
if (s[i] > d) { k=i; d=s[i]; }
return(s[k]);
}
//---------------------------------------------------- 2
void F2(char *&p, char *s)
{ p = new char[strlen(s)+1];
strcpy(p,s);
}
//---------------------------------------------------- 3
struct tree
{ int val;
tree *pr,*pl;
};
void F3(tree *&p, int v)
{
if (p==NULL)
{ p = new tree;
p->pl = p->pr=NULL;
p->val = v; return;
}
if (p->val = v) return;
if (p->val > v) F3(p->pl,v); else F3(p->pr,v);
}
//------------------------------------------------------
// Определить значения переменных после выполнения действий
//----------------------------------------------------- 4
int INC4(int &x)
{ x++; return(x+1); }
void main()
{ int x,y,z; x = 5; y = INC4(x);
z = INC4(INC4(x)); }
//----------------------------------------------------- 5
int &INC5(int &x)
{ x++; return(x); }
void main()
{ int x,y,z;
x = 5; y = INC5(x); z = INC5(INC5(x)); }
//----------------------------------------------------- 6
int *INC6(int &x)
{ x++; return(&x); }
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 &INC10();
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 &integer::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()->INC11()); }
Определите значения элементов данных объектов после выполнения переопределенных операций .
//------------------------------------------------------bk73-14.cpp
#include <stdio.h>
#include <string.h>
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 &operator+(integ2 &);
integ2 &operator+(int &);
integ2 (int v0) { val = v0; }
};
integ2 &integ2::operator+(integ2 &two)
{
val += two.val;
return(*this);
}
integ2 &integ2::operator+(int &two)
{
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 &operator+(integ3 &);
integ3 operator+(int &);
integ3 (int v0) { val = v0; }
};
integ3 &integ3::operator+(integ3 &two)
{
two.val +=val;
return(*this);
}
integ3 integ3::operator+(int &two)
{ 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 &);
string() { s=NULL; }
char operator[](int);
char &operator()(int);
string &operator=(int);
operator int ();
string &operator+(char);
string &operator+(char *);
string &operator+(string&);
};
string::string(string &src)
{ 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
#include <string.h>
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 = &b1; bbb *pb = &b1;
int x = a1.inc();
int y = b1.inc() + pa->inc();
int z = pb->inc();
}
//------------------------------------------------------ 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[] = { &A1, &B1, &C1 };
int r1 = p[0]->out() + p[1]->out() + p[2]->out();
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; }
