meimei1337//====================== start of sample.cpp ========================== class Person { public: short m_age; const char* m_name; const char* m_surname; }; class Library { public: long m_books_count; std::string m_name; static std::string m_city; }; class Program { public: std::string prog_name; long version; void* prog_data; }; class Region { public: short country_code; short city_code; std::shared_ptr<Library< main_library; };//====================== end of sample.cpp ========================== Для какого из классов в фрагменте файла sample.cpp необходима реализация своего оператора копирования? //====================== start of sample.h ========================== struct A {}; struct B; struct B *pb = 0; struct A *pa = 0; struct B b; struct A a; void foo(const struct B& in_b); //====================== end of sample.h ========================== Какие присвоения и объявления в файле sample.h валидны? //====================== start of sample.cpp ========================== class Region { short country_code; short city_code; char* city_name; public: Region(); short get_country_code() { return country_code; } inline short get_city_code() const; const char* get_city_name() const; }; Region::Region() : country_code(0) , city_code(0) , city_name(0) {} inline short Region::get_city_code() const { return city_code; } const char* Region::get_city_name() const { return city_name; } //====================== end of sample.cpp ========================== Какие из методов являются встроенными и объявлены корректно? //====================== start of sample.cpp ========================== template<unsigned long N> class binary { public: static unsigned long const value = binary<N / 10>::value << 1 | N % 10; }; template<> class binary<0> { public: static unsigned long const value = 0; }; int main(int argc, char* argv[]) { if (argc > 1) { static unsigned const two = binary<10>::value; } return 0; } //====================== end of sample.cpp ========================== Когда будет посчитано значение переменной two?//====================== start of sample.cpp ========================== class Person { public: long GetAge(); bool IsMale(); }; class Trader: private Person { public: long GetAge(); long GetAccount(); }; class Worker { public: long GetExperience(); long GetSalary(); }; class Developer : public Worker, private Person { }; class Boss: protected Worker { public: unsigned short GetLevel(); const char* GetDepartment(); }; class HeadOfAll: public Boss {};//====================== end of sample.cpp ========================== Для какого из производных классов в файле sample.cpp наследование выполнено для наследования интерфейса?//====================== start of sample.cpp ========================== #include <stdio.h> #include <stdlib.h> #include <vector> class ServiceOrganization; class BuildingElement { static char* m_city; std::vector<int> m_flats; unsigned int m_square; ServiceOrganization& m_organization; FILE *m_document; BuildingElement* m_pNext; public: BuildingElement(); BuildingElement(BuildingElement&& src) : m_square(0) , m_organization(src.m_organization) , m_document(src.m_document) , m_pNext(src.m_pNext) { m_flats = src.m_flats; src.m_flats.clear(); src.m_organization = ServiceOrganization(); ::fclose(src.m_document); src.m_document = NULL; ::free(src.m_pNext); src.m_pNext = NULL; } };//====================== end of sample.cpp ========================== Какие операции, выполняемые в конструкторе переноса в файле sample.cpp являются лишними? //====================== start of sample.cpp ========================== template <typename T> class multiplies: public binary_function<T,T,T> { public: T operator() (const T& x, const T& y) const { return x * y; } }; //====================== end of sample.cpp ========================== Какие утверждения про приведённый выше код функтора multiplies верны?//====================== start of sample.cpp ========================== class Region; class Person { public: short m_age; const char* m_name; const char* m_surname; const char* m_region_name; Person(const char* name) : m_name(name) {} operator short () {return m_age;} operator const char* () {return "";} operator Region* (); }; class Region { public: const char* region_name; const char* cheef_name; long size; Region(const char* region_nm) : region_name(region_nm) {} operator long () {return size;} operator const char* () {return region_name;} operator Person () {return Person(cheef_name);} }; Person::operator Region* () {return new Region(m_region_name);}//====================== end of sample.cpp ========================== Какие операторы преобразования класса Person не являются корректными с точки зрения архитектуры? //====================== start of sample.cpp ========================== struct Semaphor { const long power_on:1; long red:1; long yellow:1; long green:1; static long is_new_version:1; }; int main() { Semaphor my_semaphor={1}; bool is_red = my_semaphor.red; long* pyellow = &(my_semaphor.yellow); bool power_on = my_semaphor.power_on; int new_version = my_semaphor.is_new_version; return 0; } //====================== end of sample.cpp ========================== Какие присвоения битовых полей корректны (и соответственно описания этих полей) файле sample.cpp? //====================== start of sample.cpp ========================== #include <boost/shared_ptr.hpp> #include <boost/scoped_ptr.hpp> #include <boost/weak_ptr.hpp> #include <vector> struct A { virtual ~A(); }; struct B: public A {}; struct C {}; void foo1(boost::shared_ptr<A> a); void foo2(boost::weak_ptr<B>& a); void foo3(boost::shared_ptr<C> a); void foo4(boost::scoped_ptr<A>& a); void foo5(std::vector< boost::weak_ptr<C> >& c); int main(int argc, char* argv[]) { boost::shared_ptr<A> a(new A); boost::shared_ptr<B> b(new B); boost::shared_ptr<C> c(new C); boost::weak_ptr<A> b1(a); boost::weak_ptr<B> b2(b); boost::weak_ptr<C> b3(c); std::vector< boost::weak_ptr<C> > v1; v1.push_back(b3); foo1(b2.lock()); foo2(b2); try { boost::shared_ptr<C> c1(c); foo3(c1); } catch(boost::bad_weak_ptr& e) { } foo4(b2.lock()); foo5(v1); return 0; } //====================== end of sample.cpp ========================== Вызовы каких функций выполнены корректно и операции создания их параметров не содержат очевидных проблем? //====================== start of sample.cpp ========================== struct A {}; struct B {}; struct C {}; struct D {}; struct E {}; struct F {}; class BaseIO { public: virtual int state() throw(A) = 0; virtual void read() throw(A, B) = 0; virtual void write() throw (C, D) = 0; virtual void open() throw (E,F) = 0; virtual void close() throw() = 0; }; class DiskIO: public BaseIO { public: virtual int state() throw(); virtual void read() throw (A, B); virtual void write() throw (C); virtual void open() throw (A, E); virtual void close() throw (F); }; //====================== end of sample.cpp ========================== Перегрузка каких виртуальных методов базового класса в классе DiskIO выполнена корректно? //====================== start of sample.cpp ========================== class ARef { public: ARef(A &a, int i) : _a(a), _ix(i) {} ARef& operator= (T t) { return *this;} operator T() {return _t;} operator A() {return _a;} A& getA() { return _a;} bool operator == (A& a) {return _a == a;} private: A& _a; int _ix; T _t; }; class A { friend class ARef; public: A() {} ARef operator[] (int ix) {return ARef(*this, ix);} operator ARef() {return ARef(*this, ix);} }; int main() { A a; int i, j; T t; t = a[j]; return 0; } //====================== end of sample.cpp ========================== Какие из методов классов ARef и A из файла sample.cpp оказываются задействованы при операции t=a[j]? //====================== start of sample.cpp ========================== #include <climits> #include <limits> #include <boost/static_assert.hpp> namespace name { BOOST_STATIC_ASSERT(std::numeric_limits<int>::digits == 32); } int main(int argc, char* argv[]) { return 0; } //====================== end of sample.cpp ========================== Что случится c программой из файла sample.cpp если в системе размер int больше 32 разрядов?//====================== start of sample.cpp ========================== bind2nd(greater<int>(), 100); //====================== end of sample.cpp ==========================Какие утверждения про приведённый выше адаптер верны?
//====================== start of sample.h ========================== #include <algorithm> int main(int argc, char* argv[]) { size_t N = 40; int A[N]; size_t B[N*2]; char C[N]; int D[N]; std::replace(&B[0], &B[N/2], 0, 42); std::replace(C, (C+N+1), 'D', 'T'); std::copy(&A[0], &A[N-1], &D[0]); std::copy(A, (A+N), D); return 0; } //====================== end of sample.h ========================== В каких из вызовов обобщённых алгоритмов встроенные массивы С++ использованы без ошибок? //====================== start of sample.cpp ========================== #include <type_traits> class A { public: A(int in = 5); }; int main() { std::true_type my_true; std::false_type my_false; return 0; } //====================== end of sample.cpp ========================== Какие утверждения о переменных my_true и my_false верны? //====================== start of sample.cpp ========================== template <class Element, unsigned long max_size> class Storage { public: Storage(Element) {} }; template <class Element> class Storage <Element, 0 /* unlimited*/> { public: Storage(Element e) {} }; template <unsigned long max_size> class Storage <int, max_size> { public: Storage(int e) {} }; template <> class Storage<char*, 0> { public: Storage(char* s) {} }; template <> class Storage<char*, 100> { public: Storage(char* s) {} }; int main() { int p1=4; Storage<int, 5> st1(p1); Storage<char*, 100> st2(char* s); Storage<double, 80000> st3(double n); Storage<double, 0> st4(double n); return 0; } //====================== end of sample.cpp ========================== Какой из шаблонов Storage в файле sample.cpp не задействован в функции main в файле sample.cpp?//====================== start of sample.cpp ========================== class Input { public: Input(); ~Input(); virtual void f(); }; class ManualUserDev: public Input { public: ManualUserDev(); virtual ~ManualUserDev(); }; class Keyboard: public Input { public: Keyboard(); ~Keyboard(); }; int main() { Keyboard keyboard; Input& rinp = keyboard; Input* pinp = &:keyboard; ManualUserDev& rmy_mdev = dynamic_cast<ManualUserDev&>(rinp); ManualUserDev* pmy_mdev = dynamic_cast<ManualUserDev*>(pinp); Keyboard& rmy_keyboard = dynamic_cast<Keyboard&>(rinp); Keyboard* pmy_keyboard = dynamic_cast<Keyboard*>(pinp); return 0; }//====================== end of sample.cpp ========================== При инициализации какой переменной в файле sample.cpp будет брошено исключение?//====================== start of sample.cpp ========================== class Input { public: Input(); ~Input(); }; class USBDev { public: ~USBDev(); }; class USBInput: public Input { USBDev m_dev; public: USBInput(): Input() {} ~USBInput(); }; class Device { public: Device(); ~Device(); }; class ManualUserDev: public Device { public: ManualUserDev() : Device() {} ~ManualUserDev(); }; class Key { public: ~Key(); }; class Keyboard: public USBInput, public ManualUserDev { Key* key; public: Keyboard(): ManualUserDev(), Input() {key = new Key();} ~Keyboard() { delete key; } };//====================== end of sample.cpp ========================== В каком порядке вызываются деструкторы при удалении объекта Keyboard из файла sample.cpp? //====================== start of sample1.h ========================== struct S_EMPTY {}; typedef S_EMPTY my_empty_str; typedef std::vector<int> my_vector; typedef char[15] my_char15; class B { long jj; public: char _str[6]; private: static char str_4_all[9]; }; typedef B my_B; union mytypes_t { int i; float f; } My; typedef mytypes_t __My; //====================== end of sample1.h ========================== Какие из типов, описанных в файле sample1.h (выше), являются классом в широком смысле этого слова? //====================== start of sample.cpp ========================== #include <boost/shared_ptr.hpp> #include <boost/scoped_ptr.hpp> #include <boost/weak_ptr.hpp> #include <vector> struct A { virtual ~A(); }; struct B: public A {}; struct C {}; void foo1(boost::scoped_ptr<A> a); void foo2(boost::scoped_ptr<B>& a); void foo3(boost::shared_ptr<C> a); void foo4(boost::scoped_ptr<A>* a); void foo5(std::vector< boost::scoped_ptr<C> >& c); int main(int argc, char* argv[]) { boost::scoped_ptr<A> b1(new A); boost::scoped_ptr<B> b2(new B); boost::scoped_ptr<C> b3(new C); boost::scoped_ptr<A> b4; std::vector< boost::scoped_ptr<C> > v1; v1.push_back(b3); foo1(b1); foo2(b2); foo3(b3.lock()); foo4(&b4); foo5(v1); return 0; } //====================== end of sample.cpp ========================== В каких из функциях умный указатель boost::scoped_ptr используется правильно? //====================== start of sample.cpp ========================== #include <boost/variant/variant.hpp> struct A {}; struct B { B(int src); private: B(const B& src); }; struct C { C(int src); private: C(); }; struct D {}; int main(int argc, char* argv[]) { boost::variant<int, A, B, C> myvariant; int x; int* y; A a; B b(x); C c(x); D d; myvariant = x; myvariant = y; myvariant = a; myvariant = b; myvariant = c; myvariant = d; return 0; } //====================== end of sample.cpp ========================== Какие объекты можно присвоить объекту myvariant из примера в файле sample.cpp?![](https://s.studizba.com/z.php?f=/templates/si/i/noavatar.png&w=100&h=100&t=1"){kind=avatar}
