База ответов ИНТУИТ

Программирование на С/С++

<<- Назад к вопросам

<pre> //====================== ========================== class A { int _i; char* _name; public: A(); A(const A&amp; a); ~A(); A&amp; operator=(const A&amp; a); bool operator==(const A&amp; a) const; const char* getName() const; }; class B { public: B(int i, const char* name); ~B(); bool operator==(const B&amp; 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&amp; operator=(C c); const char* getName() const; int getIndex() const; int setIndex(); private: int _i; char* _name; }; class D { public: D(); D(const D&amp; d); ~D(); D&amp; operator=(const C&amp; d); int _i; char* _name; }; //====================== ========================== </pre> Код какого из приведённых в фрагменте кода классов соответствуют сложившимся эмпирическим правилам организации исходного кода на С++ и канонической форме класса?

(Отметьте один правильный вариант ответа.)

Варианты ответа
DRef(Верный ответ)
ARef
CRef
BRef
Похожие вопросы
<pre>//====================== start of sample.cpp ========================== #include &lt;stdio.h&gt; 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 &quot;&quot;;} }; class Region { public: const char* region_name; const char* cheef_name; long size; Region(const char* region_nm = &quot;&quot;) : region_name(region_nm) {} operator long () {return size;} operator const char* () {return region_name;} }; int main() { Person p1(&quot;Vasily Ivanov&quot;); Region r; printf(&quot;Region number %u, driver %s&quot;, static_cast&lt;unsigned short&gt;(r), static_cast&lt;const char*&gt;(p1)); return 0; }//====================== end of sample.cpp ========================== </pre> Какие из имеющихся в файле sample.cpp конструкторов и операторов преобразования задействованы в операциях в функции main()?
<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 &quot;&quot;;} 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 ========================== class User { public: struct Region { short country_code; short city_code; static char* city_name; }; const char* name; int age; double balance; Region region; const char* get_name() const { return (*this).name; } int get_age() const { return this-&gt;age; } double get_balance() const { return (*this)-&gt;balance; } short get_country_code() const { return Region::country_code; } short get_city_code() const { return region.city_code; } const char* get_city_name() const { return Region::city_name; } }; //====================== end of sample.cpp ========================== </pre> В каких методах обращения к членам объекта класса user типа User корректны?
<pre> //====================== start of sample.cpp ========================== #include &lt;iostream&gt; class Program; class ProgDataGetter { public: const char* prog_name(const Program&amp; prg); long get_version(const Program&amp; 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&amp; operator &gt;&gt; (std::iostream&amp; io, Program&amp; prg); friend std::iostream&amp; operator &lt;&lt; (std::iostream&amp; io, const Program&amp; prg); friend class VersionGetter; friend const char* ProgDataGetter::prog_name(const Program&amp;); }; std::iostream&amp; operator &gt;&gt; (std::iostream&amp; io, Program&amp; prg) { io &gt;&gt; prg.prog_name &gt;&gt; prg.threads_count; } std::iostream& operator &lt;&lt; (std::iostream& io, const Program& prg) { io &lt;&lt; prg.prog_name &lt;&lt; prg.modules[0].module_name &lt;&lt; prg.modules[1].module_name; } class VersionGetter { public: long get_version(Program&amp; prg) { return prg.version; } }; const char* ProgDataGetter::prog_name(const Program&amp; prg) { return prg.prog_name; } long ProgDataGetter::get_version(const Program&amp; prg) { return prg.version;} //====================== end of sample.cpp ========================== </pre> Для каких функций и методов корректно организован доступ к членам класса Program файле sample.cpp?
<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 &lt;vector&gt; 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&lt;unsigned char&gt;* mybuffer = new std::vector&lt;unsigned char&gt;(sizeof(Person) + sizeof(Region), 0); Person* my_person = new (&amp;(mybuffer->at(0))) Person(); my_person-&gt;~Person(); delete my_person; Region* p_region = new (&amp;(mybuffer-&gt;at(0))) Region(); p_region-&gt;~Region(); delete p_region; delete mybuffer; return 0; }//====================== end of sample.cpp ========================== </pre> Какие операции освобождений ресурсов в файле sample.cpp являются лишними или ошибочными?
<pre> //====================== start of sample.cpp ========================== template&lt;unsigned long N&gt; class binary { public: static unsigned long const value = binary&lt;N / 10&gt;::value &lt;&lt; 1 | N % 10; }; template&lt;&gt; class binary&lt;0&gt; { public: static unsigned long const value = 0; }; template&lt;&gt; class binary&lt;1&gt; { public: static unsigned long const value = 1; }; int main(int argc, char* argv[]) { static unsigned const x0 = binary&lt;0&gt;::value; static unsigned const x1 = binary&lt;1000&gt;::value; static unsigned const x2 = binary&lt;1001&gt;::value; static unsigned const x3 = binary&lt;1010&gt;::value; static unsigned const x4 = binary&lt;1011&gt;::value; return 0; } //====================== end of sample.cpp ========================== </pre> При инициализации какой переменной не будет использоваться конкретизация шаблона с параметром 0?
<pre>//====================== start of sample.cpp ========================== #include &lt;vector&gt; class Person { short m_age; const char* m_name; const char* m_surname; public: Person(short age, const char* name, const char* subname) : m_age(age), m_name(name), m_surname(subname){} Person() : m_name(&quot;unknown&quot;){} }; class Reader: public Person { long m_ticket_number; public: Reader(long tick_numb = 0) : Person() , m_ticket_number(tick_numb) {} Reader(short age, const char* name, const char* surname, long tick_numb) : Person(age, name, surname) , m_ticket_number(tick_numb){} }; int main() { Reader reader1; Reader reader2 = 35; Reader reaedr3(22, &quot;Vasily&quot;, &quot;Ivanov&quot;, 123456); return 0; }//====================== end of sample.cpp ========================== </pre> Значения каких атрибутов каких объектов корректно инициализируются не нулевыми значениями?
<pre> //====================== start of sample.cpp ========================== template &lt;typename T&gt; class multiplies: public binary_function&lt;T,T,T&gt; { public: T operator() (const T&amp; x, const T&amp; y) const { return x * y; } }; //====================== end of sample.cpp ========================== </pre> Какие утверждения про приведённый выше код функтора multiplies верны?
<pre> //====================== 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 ========================== </pre> Какие из методов являются встроенными и объявлены корректно?