Народ, помогите, плиз, ответить на пару вопросов по ООП:
1. Чему эквивалентна запись: #define CONV(A,B) *A,*B
2. Что означает запись: #define swap(a,b) {int a##b=a; a=b, b=a##b;}
3. Почему следуюая запись некорректна: #define swap(a,b) {int a##b=a, a=b; b=a##b;}
4. Что означает запись: #pragma argused
5. Что означает запись: #undef
6. Зачем нужен страж включения при использовании: #include
7. Что означает запись: namespace A {int B; int C;} …; using A::B; A::B=A::C;
8. Что означает запись: asm {…}
9. Чем отличается запись: …; return 5; от записи …; return;
10. Назовите четыре оператора, позволяющие организовать бесконечный цикл, приведите примеры.
11. Что означает запись: T *A = new X*[y];
12. Что означает запись: T **A = new X[y];
13. Что означает запись: void *F(int X) {return (void*)X;} …; void *A=F(5);
14. Что означает запись, чему будет равно А: int& F(int* X) {return *(X+1);} …; int b[3] = {5,6}; int A = F(b);
15. Почему запись некорректна: int A=F(X++);
16. Почему запись некорректна: int **A=new int*[1]; …; delete A;
17. Что означает запись: int ***X[2][3][4];
18. Какие существуют ограничения на X, Y и Z в записи: int D[X][Y][Z];
19. Что означает запись, почему она некорректна: enum S {A,B,C=08,D='\\'} E = 4; …; E=A+1;
20. Что означает запись: void F(/*const int **/const int &) const;//F(5)
21. Что означает запись: int a[6] = {1,2,3,4,5};int y=a[5]+int(a)+5+*a*5;
22. Что означает запись, чему будет равно А: int f(int a, int b=3) {return a *b;} …; int A=f(3,4)+f(4);
23. Что означает запись: int a=5;struct S{int a,b; int F(int a){return a *::a;}} M={2,3}; …; int A=M.F(4);
24. Что означает запись: class X{int* F(int);}; int *X::F(int a){return new int[a];}
25. Что означает запись: class X{int a; public: X(){a=0;} X(int b){a=b;} X(X &c){a=c.a;} };
26. Что означает запись: UNIОN X{int a; signed int b; unsigned int c;} Y;
27. Что означает запись: *(&(A.B.C[5]->X)+3);
28. Что означает запись: (*(A->B.C))->D;
29. Что означает запись: &*A и чем она отличается от записи: *&A
30. Что означает запись: int x=8;void f(){static int x=6;x++;::x=x;} …; int x=5;f();f();::x=x;
31. Чему будет равно А, обяснить почему: int A=5; A=~A; A<<=2; A|=1; A&=5; A^=1;
32. Что означает запись, чему она эквивалентна: inline int F(int X){return X*X;} …; int A=F(5);
33. Чему будут равны C и D, объяснить почему: int A=5,B=7,C=(A&B)^(A&&B),D=~(!0);
34. Упростить запись, избавившись от оператора ",": F(a, (b = 1, b + 4), c);
35. Что означает запись: struct A{int x; A& X(void) {return *this;}} B; B.X().X().X().x = 5;
36. Почему запись некорректна: struct X{const int a; const int& b;}; X Y;
"всего-то" ©)))
________________________
p.s. 26. UNIОN в данном случае пишется с маленькой буквы, ибо по неведомым причинам vkontakte автоматически меняет его регистр
18 ноября 2007 в 23:02
Всем спасибо – действительно было пару заморочистых вопросиков…
18 ноября 2007 в 22:03
Огоромное спасибо всем, кто отписался здесь! Вы выручили очень много народа))
18 ноября 2007 в 19:00
спасибо всем, кто напрягал мозги для нас
18 ноября 2007 в 9:03
На вопрос №13 уже отвечал Сергей ShTiRLiC Шпикин
Функция принимает целое число, приводит его к типу "указатель на void" и возщвращает получившийся указатель.
void *A = F(5);
Переменная A (указатель) будет указывать на 5-й байт памяти
18 ноября 2007 в 1:02
Несправедливо обделили вниманием следующие вопросы:
1. Чему эквивалентна запись: #define CONV(A,B) *A,*B
13. Что означает запись: void *F(int X) {return (void*)X;} …; void *A=F(5);
20. Что означает запись: void F(/*const int **/const int &) const;//F(5)
30. Что означает запись: int x=8;void f(){static int x=6;x++;::x=x;} …; int x=5;f();f();::x=x;
32. Что означает запись, чему она эквивалентна: inline int F(int X){return X*X;} …; int A=F(5);
вроде всё… судный день – понедельник… систематизирую данные
p.s. всем ОГРОМНОЕ спасибо за помощь! как проверят – обязательно отпишусь
p.p.s. есть предположение, что этот топик читает вся моя группа, кого смогу заставить – пригоню сюда со словами благодарности
15 ноября 2007 в 14:02
19. Что означает запись, почему она некорректна: enum S {A,B,C=08,D='\\'} E = 4; …; E=A+1;
Тут много ошибок
1. 08 – запись числа с первой цифрой "0" означает запись в восьмеричной системе, в ней используются цифры от 0 до 7, 8 – неправильно
2. E = 4 – во-первых, отсутствует приведение от инта к энуму, в таком случае нужно писать явный каст. Во-вторых, неопределено, какое из значений энума эквивалентно числу "4"
3.E = A + 1 – аналогично, отсутствует приведение типов
14 ноября 2007 в 21:03
да, это нормально X Y; означает объявление переменной типа X и с именем Y (перед этим тип данных X описан – эта самая структура)
14 ноября 2007 в 18:01
>>36. Почему запись некорректна: struct X{const int a; const int& b;}; X Y;
первое что бросается в глаза так это связка "X Y;" (Икс пробел Игрек;)
это вообще нормально?
14 ноября 2007 в 17:05
ааа..)))) сэнкс
14 ноября 2007 в 17:04
Вот такой вопрос:
A = 5 // 0×00000005
B = 7 // 0×00000007
A & B // побитовая операция "И", результат равен 0×00000005
т.е. если оба операнда "true", то он удерживает значение первого, в противном случае 0, так? первая мысль: результат равен 0×0000000С
14 ноября 2007 в 17:04
не, true/false тут не при чём – операция побитовая
младший байт операндов равен:
A = 0000 0101 //4+1=5
B = 0000 0111 //4+2+1=7
теперь помня о том, что 1 И 1 = 1, 1 И 0 = 0, 0 И 0 = 0 полчаем
0000 0101
14 ноября 2007 в 17:02
<Мастер Пинский>
я в истерике!!!
Тогда так:
33. Чему будут равны C и D, объяснить почему: int A=5,B=7,C=(A&B)^(A&&B),D=~(!0);
В выражении присутствует смесь побитовых и логических операций
A = 5 // 0×00000005
B = 7 // 0×00000007
A & B // побитовая операция "И", результат равет 0×00000005
A && B // логическая операция "И", A неравно нулю и B не равно нулю, следовательно оба операнда "true", результат тоже "true", то есть "1", 0×00000001
^ // побитовое исключающее ИЛИ (XOR), 0×00000005 ^ 0×0000001 = 0×00000004
Следовательно C = 4
!0 //логическое отрицание, 0 – "false", отрицание – "true", т.е. 1, 0×00000001
~ //побитовое отрицание ~(0×00000001) = 0xFFFFFFFE, т.е. -2
Следовательно D = -2
Итого: C = 4, D = -2
14 ноября 2007 в 17:01
>> Синтаксическая ошибка, не скомпилится.
>> Может быть в выражении D=~(|0) должена стоять не "|" (вертикальная черта), а "!" (восклицательный знак)? Тогда выражение валидно.
>> Либо это вопрос с повохом.
исследовал исходник на качество печати и пришёл к выводу, что тест был напечатан на струйном принтере на обычной бумаге… вывод? капли чернил растеклись по волокнам листа, что повлекло за собой слияния "!" в "|"… хотя до сих пор этот момент трудно различим, но раз Мастер Пинский говорит, что мол "ERROR" и всё тут, то вероянто это действительно так ^^
14 ноября 2007 в 16:04
поправка, повыяснял тут – запись корректна (решётка, вроде бы, означает подстановку символического имени параметра макроса).
Ну а ошибка тут в использовании "," вместо ";" в выражении int a##b=a, a=b;
14 ноября 2007 в 13:00
3. Почему следуюая запись некорректна: #define swap(a,b) {int a##b=a, a=b; b=a##b;}
Ты уверен, что именно a##b (через решётки)? А то как-то странно выглядит конструкция…
14 ноября 2007 в 12:05
35. Что означает запись: struct A{int x; A& X(void) {return *this;}} B; B.X().X().X().x = 5;
Определяется структура A с одним внутренним полем x, и одним методом X, который возвращает ссылку на этот же объект.
Сразу же объявляется переменная типа этой структуры.
B.X().X().X() – можно писать сколько угодно последовательных вызовов функции X, каждый раз будет возвращаться ссылка на объект B
так что B.X().X().X() равно просто B
B.X().X().X().x = 5; – полю x объекта B присваивается значение 5
Итого B.x присваивается значение 5 и эта запись эквивалентна просто B.x = 5;
14 ноября 2007 в 12:05
33. Чему будут равны C и D, объяснить почему: int A=5,B=7,C=(A&B)^(A&&B),D=~(|0);
Синтаксическая ошибка, не скомпилится.
Может быть в выражении D=~(|0) должена стоять не "|" (вертикальная черта), а "!" (восклицательный знак)? Тогда выражение валидно.
Либо это вопрос с повохом.
14 ноября 2007 в 12:04
28. Что означает запись: (*(A->B.C))->D;
A – указатель на объект, структуру или юнион
A->B – обращение через указатель к полю B объекта
B – также является объектом, структурой или юнионом
A->B.C – обращение к полю C объекта B
*(A->B.C) – C является указателем, * – обращение к переменной по этому адресу
(*(A->B.C)) – скобки для приоритета операций
(*(A->B.C))->D – по адресу C находится другой указатель (тоже на объект, структуру или юнион), через оперецию "->" производится обращение к полю D объекта, на который указывает указатель, находящийся по адресу C
2 Дарья Кафтан
))
Спасибо
14 ноября 2007 в 12:04
34. Упростить запись, избавившись от оператора ",": F(a, (b = 1, b + 4), c);
Оператор "," описывает последовательное выполнение действий, т.е. сперва b будет присовено значение 1, а потом к нему прибавится 4.
Соответственно можно написать F(a, 5, c); либо (если значение b нужно где-то дальше в программе), то b = 1; F(a, b + 4, c);
13 ноября 2007 в 23:04
спасиб. точняк*а!!!! как эт я не догадалося?
ух молодец Пинский! хвалю!
13 ноября 2007 в 23:03
исправил:
20. очепятка "constt" —> "const"
24. в конце была лишняя "};" —> убрал
26. очепятка "unsidned" —> "unsigned"
32. очепятка "int F()int X)" —> "int F(int X)"
p.s. по неведомым причинам, vkontakte автоматически меняет регистр UNIОN
13 ноября 2007 в 23:00
31. Чему будет равно А, обяснить почему: int A=5; A=~A; A<<=2; A|=1; A&=5; A^=1;
Побитовые операции
int A = 5; // присвоение, A = 0×00000005
A = ~A;// побитовое отрицание, A = 0xFFFFFFFA
A<<=2;// сдвиг слево на 2 позиции, A = 0xFFFFFFE8
A |= 1;// побитовое "ИЛИ" с единицей, A = 0xFFFFFFE9
A &= 5; // побитовое "И" с пятёркой, A = 0×00000001
A ^= 1; // исключающее или (XOR) с единицей, A = 0×00000000
Итого, A равно нулю.
13 ноября 2007 в 22:05
2 Александр Зло Пинский
>> <вот именно, что в вопросе звучит именно "argused">
>> Хм, тогда не знаю, что это такое. Это тебе в универе задание дали? >> Может опечатка?
да)))) кстати, в полне возможно, ибо есть предположение, что препод печатал "ЭТО" из головы))) тогда тут играет "человеческий фактор")
>>26. Синтаксическа ошибка – слова UNIОN и unsidned неизвестно что такое.
вот здесь признаюсь, кривые пальцы — моя вина =]
на всякий случай перепроверю ещё раз…
13 ноября 2007 в 22:04
2 Дарья Кафтан
27. Верно
29. По-моему наоборот. Хотя не уверен, на C++ давно не писал, а справки под рукой нет.
30. ХЗ, по-моему это вообще не должно скомпилиться
36. Вроде верно
13 ноября 2007 в 22:04
2Макаров Вася: конечно нет, такая строка вполне уместна. Просто вопрос-то стоит "почему некорректна" и как-то странно отвечать "нипочему". В общем, странный вопрос.
В п.7 я затупил, ага. using вообще можно опустить.
13 ноября 2007 в 22:04
26. Синтаксическа ошибка – слова UNIОN и unsidned неизвестно что такое.
А вот если там UNIОN (маленькими буквами) и unsigned, тогда это означает следующее:
UNIОN X{int a; signed int b; unsigned int c;} Y;
Описывается юнион с именем X (юнион, это такая штука, что сколько в ней элементов не напиши, размер будет равен размеру максимального – в данном случае int – а все элементы находятся по рдному адресу в памяти). И сразу же объявляется переменная Y типа X.
[EDIT]
Что за нах?!?!?! почему маленькие буквы на большие заменяются в слове u_n_i_o_n?!?!?
13 ноября 2007 в 22:03
Пока писал, уже опередили
))
13 ноября 2007 в 22:03
2 Дарья Кафтан
21. IMHO не совсем верно – *a*5 не адрес нулевого элемента умножается на 5, а его значение
22. Верно
23. Верно
24. Верно, но дополнение – функция создаёт массив интов размера "a" и возвращает его адрес
25. По-моему верно
13 ноября 2007 в 22:02
27. Что означает запись: *(&(A.B.C[5]->X)+3);
это обращение по адресу, равному сумме адреса икса из це пятого из б из а плюс три.
29. Что означает запись: &*A и чем она отличается от записи: *&A
первое – это ссылка на указатель на А, а второе – это указатель на ссылку на А.
30. Что означает запись: int x=8;void f(){static int x=6;x++;::x=x;} …; int x=5;f();f();::x=x;
бред…. зачем два раза инициализировать иксюху в одном и том же месте??
13 ноября 2007 в 22:02
ответьте, я правильно сказала?
13 ноября 2007 в 22:02
2 Илья SEMER Ухин
<вот именно, что в вопросе звучит именно "argused">
Хм, тогда не знаю, что это такое. Это тебе в универе задание дали? Может опечатка?
21. Запись int a[6] = {1,2,3,4,5};int y=a[5]+int(a)+5+*a*5; означает следующее:
int a[6] = {1,2,3,4,5};
/*
Объявляется массив из шести элементов
*/
int y=a[5]+int(a)+5+*a*5;
/* Выражение вычисляется так:
1. a[5] – пятый элемент массива
2. int(a) – приведение "a" к типу int (имя массива равно адресу начала массива)
3. 5 – просто константа
4. *a*5 – *a обращение через указатель к переменной по адресу "a" т.е. начало массива, нулевой элемент, *5 умножение значения на пять. Итого, это выражение эквивалентно a[0] * 5 = 1 * 5
Всё вышеперечисленное суммируется.
22. Что означает запись, чему будет равно А: int f(int a, int b=3) {return a *b;} …; int A=f(3,4)+f(4);
f – функция с пареметром со значением по умолчанию (т.е. этот параметр является необязательм и при вызове функции его можно не указывать, тогда он будет иметь значение по умолчанию)
Сама функция возвращает произведение своих параметров.
При вычислении выражения функция вызывается один раз с параметрами 3 и 4 (результат 12) и второй раз с одним параметром a = 4, при этом имеет значение по умолчанию – 3, результат снова равен 12, ну а результат всего этого 12 + 12 = 24
13 ноября 2007 в 22:02
36. Почему запись некорректна: struct X{const int a; const int& b;}; X Y;
потому что у тебя там две константы с непонятным значением, а так не бывает, ведь потом ты, когда объявляешь игрек, вроде как присваиваешь им что-то новое. это бред. в общем, просто так константы писать не нада
13 ноября 2007 в 22:01
21. int a[6] = {1,2,3,4,5};int y=a[5]+int(a)+5+*a*5;это значит массив из 6-ти элементов типа интеджер, причем пять ужо указано. а игрек – это сумма пятого элемента с адресом первого эл-та массива плюс пять плюс опять сумма адреса ток умноженного на пять.
22. Что означает запись, чему будет равно А: int f(int a, int b=3) {return a *b;} …; int A=f(3,4)+f(4);
функция Эф с двумя целочисленными параметрами причем второй из них по умолчанию равен трем, причем возвращает их произведение =). а А будет равно 24.
23. Что означает запись: int a=5;struct S{int a,b; int F(int a){return a *::a;}} M={2,3}; …; int A=M.F(4);
целое а равно пяти. структура С состоит из двух членов а и б и одного метода, возвращающего произведение параметра а на а внешнего простр. элемент эм типа эс причем его члены равны 2 и 3.А равно двадцати.
24. Что означает запись: class X{int* F(int);}; int *X::F(int a){return new int[a];} };
класс икс состоящий из одного закрытого метода Эф. причем в классе только прооттип метода, а его объявление – потом, после.
25. Что означает запись: class X{int a; public: X(){a=0;} X(int b){a=b;} X(X &c){a=c.a;} };
класс икс с закрытым членом а и открытым конструкторами икс() и икс(инт б) и копирующим конструктором икс(ссылка на объект типа икс)
13 ноября 2007 в 22:00
2"Александр Зло Пинский":
вот именно, что в вопросе звучит именно "argused"
p.s. перепроверил ещё раз, добавил вторую часть…
13 ноября 2007 в 18:03
11.T *A = new X*[y];
Дословно это означает:
Объявление переменной А типа "указатель на Т" и присваивание ей указателя на первый элемент вновь созданного массива элементов типа "указатель на Х" размерностью у.
Примечание: всё эт дело будет работать только если тип Т — "указатель на Х", либо может быть неявно в него преобразован.
12. T **A = new X[y];
В принципе то же самое (тип А — "указатель на указатель на Т"), только наоборот — теперь Х должен быть типа "указатель на Т", либо возможно неявное преобразование.
13 ноября 2007 в 18:00
14. Я думаю что если использовать ссылку на анонимный экземпляр вне блока, внутри которого он создан, то ничего хорошего не получится
13 ноября 2007 в 18:00
15. Сергей ShTiRLiC Шпикин становится ли от этого запись некорректной?
13 ноября 2007 в 18:00
17. объявление и статическое выделение трехмерного массива указателей на указатели на указатели на экземпляры типа Х))
13 ноября 2007 в 17:05
12. А ну это выделение памяти в куче для массивы из у элементов типа Х, объявление указателя на указтель на экземляр Т и присвоение ему значения адреса первого элемента массива.
13 ноября 2007 в 12:01
4. #pragma argsused (а не argused) насколько знаю, пишется перед объявлением функции main в виде main(int argc, char* argv[]) чтобы не было ворнингов, если не используешь эти самые argc и argv.
7. Работать будет, так как не смотря на то, что using сделан только для B, в выражении A::B=A::C; имя неймспейса указанно явно для обоих переменных (собственно говоря, работать будет и без using A::B;). Ну а означает эта запись следующее: объявляется неймспейс с двумя переменными внутри, делается using одной из переменных (чтобы можно было обращаться к ней без префикса неймспейса, значени одной переменной присваивается другой).
16. Запись некорректна потому, что выделение памяти было с использованием [] (т.е. массива, хоть и из одного элемента), а освобождение через delete (для одной переменной), нужно использовать delete[] A;
18. X, Y, Z должны быть целыми положительными числами.
Сейчас занят, не могу больше писать, потом ещё напишу.
13 ноября 2007 в 9:04
Классный тест… Где взял?
10. for{;;} {…}
do {…} while(true);
while(true) {…}
metka: …; goto metka;
13 ноября 2007 в 7:05
Нда, что-то про ООП тут негусто, в основном чисто примочки С++.
2. Видимо, обмен значениями двух переменных.
5. Отмена определения того, что было определено через #define.
6. Чтобы избежать двойного включения одного и того же хедера, что приведет к дупликации деклараций и неоднозначностям.
7. Не будет работать, т.к. using сделан только для переменной B из неймспейса A, но не для C.
8. Ассемблерная вставка.
9. Первая возвращает значение из функции, вторая нет. Первая применяется, когда у функции есть возвращаемое значение, вторая – когда его нет (т.е. void).
13. Функция возвращает указатель, который указывает на X-ю ячейку памяти. После выполнения функции, указатель А будет указывать на 5-й байт (в винде любые обращения по указателю с адресом меньше 0х10000 приведут к Access Violation, это просто для справки).
15. Будет фактически вычислено F(X), т.к. инкремент постфиксный. Чтобы вычислить значение от увеличенного X, надо писать F(++X).
На остальные вопросы либо лень отвечать, либо я не знаю ответа и лень думать =)