<pre> //====================== 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; }; template<> class binary<1> { public: static unsigned long const value = 1; }; int main(int argc, char* argv[]) { static unsigned const x0 = binary<0>::value; static unsigned const x1 = binary<1000>::value; static unsigned const x2 = binary<1001>::value; static unsigned const x3 = binary<1010>::value; static unsigned const x4 = binary<1011>::value; return 0; } //====================== end of sample.cpp ========================== </pre> При инициализации какой переменной не будет использоваться конкретизация шаблона с параметром 0?
<pre> //====================== 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[]) { static unsigned const xyz = binary<111>::value; return 0; } //====================== end of sample.cpp ========================== </pre> Конкретизация шаблона с значением 111 приводит:
<pre> //====================== 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 ========================== </pre> Когда будет посчитано значение переменной two?
<pre>//====================== start of sample.cpp ========================== #include <stdio.h> 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 "";} }; 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;} }; int main() { Person p1("Vasily Ivanov"); Region r; printf("Region number %u, driver %s", static_cast<unsigned short>(r), static_cast<const char*>(p1)); return 0; }//====================== end of sample.cpp ========================== </pre> Какие из имеющихся в файле sample.cpp конструкторов и операторов преобразования задействованы в операциях в функции main()?
<pre> //====================== ========================== class A { int _i; char* _name; public: A(); A(const A& a); ~A(); A& operator=(const A& a); bool operator==(const A& a) const; const char* getName() const; }; class B { public: B(int i, const char* name); ~B(); bool operator==(const B& b) const; const char* getName() const; int getIndex() const; private: int _i; char* _name; }; class C { public: C(); C(C c); C(int i, const char* name); ~C(); C& operator=(C c); const char* getName() const; int getIndex() const; int setIndex(); private: int _i; char* _name; }; class D { public: D(); D(const D& d); ~D(); D& operator=(const C& d); int _i; char* _name; }; //====================== ========================== </pre> Код какого из приведённых в фрагменте кода классов соответствуют сложившимся эмпирическим правилам организации исходного кода на С++ и канонической форме класса?
<pre> //====================== start of sample.cpp ========================== class User { public: const char* get_name() const; inline int get_age const; private: volatile double get_balance(); mutable char* get_job_name(); protected: long long get_phone_number(); static int get_phone_prefix(); }; //====================== end of sample.cpp ========================== </pre> Какие методы класса User объявлены корректно?
<pre>//====================== start of sample.cpp ========================== #include <vector> class Person { public: short m_age; const char* m_name; const char* m_surname; const char* m_region_name; }; class Region { public: const char* region_name; const char* cheef_name; long size; }; int main() { std::vector<unsigned char>* mybuffer = new std::vector<unsigned char>(sizeof(Person) + sizeof(Region), 0); Person* my_person = new (&(mybuffer->at(0))) Person(); my_person->~Person(); delete my_person; Region* p_region = new (&(mybuffer->at(0))) Region(); p_region->~Region(); delete p_region; delete mybuffer; return 0; }//====================== end of sample.cpp ========================== </pre> Какие операции освобождений ресурсов в файле sample.cpp являются лишними или ошибочными?
<pre>//====================== 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 ========================== </pre> Какие операторы преобразования класса Person не являются корректными с точки зрения архитектуры?
<pre> //====================== start of sample.cpp ========================== #include <iostream> class Program; class ProgDataGetter { public: const char* prog_name(const Program& prg); long get_version(const Program& prg); }; class Program { long threads_count; double time_of_work; class Module { char* module_name; }; char* prog_name; long version; Module modules[16]; friend std::iostream& operator >> (std::iostream& io, Program& prg); friend std::iostream& operator << (std::iostream& io, const Program& prg); friend class VersionGetter; friend const char* ProgDataGetter::prog_name(const Program&); }; std::iostream& operator >> (std::iostream& io, Program& prg) { io >> prg.prog_name >> prg.threads_count; } std::iostream& operator << (std::iostream& io, const Program& prg) { io << prg.prog_name << prg.modules[0].module_name << prg.modules[1].module_name; } class VersionGetter { public: long get_version(Program& prg) { return prg.version; } }; const char* ProgDataGetter::prog_name(const Program& prg) { return prg.prog_name; } long ProgDataGetter::get_version(const Program& prg) { return prg.version;} //====================== end of sample.cpp ========================== </pre> Для каких функций и методов корректно организован доступ к членам класса Program файле sample.cpp?
<pre> //====================== start of sample.cpp ========================== class Program { const char* prog_name; long threads_count; mutable double time_of_work; public: const char* get_name() const { return prog_name; } long get_threads_count() { return threads_count; } bool set_time_of_work(double in_time) const { time_of_work = in_time; return true; } bool add_time_of_work(double in_time) { time_of_work += in_time; return true; } }; const Program& get_my_program(); int main() { const Program& prg = get_my_program(); const char* prg_name1 = prg.get_name(); long my_thr_count1 = prg.get_threads_count(); bool result1 = prg.add_time_of_work(1); Program& prg2 = const_cast<Program& >(prg); long my_thr_count2 = prg2.get_threads_count(); bool result2 = prg2.set_time_of_work(0); bool result3 = prg2.add_time_of_work(1); return 0; } //====================== end of sample.cpp ========================== </pre> При присвоении значений каким переменным в файле sample.cpp корректно используются корректно определённые методы?