Программирование на С/С++ - тест 76

//====================== start of sample.cpp ==========================
		struct Book {
			short year;
			char* author;
			char* name;
		};
		class Person {
			short m_age;
			const char* m_name;
			const char* m_subname;
		public:
			Person(short age, const char* name, const char* subname)
			: m_age(age), m_name(name), m_subname(subname){}
		};
		
		class Library {
		public:
			long  m_books_count;
			char* m_name;
			char* m_city;
			Library(long books_count): m_books_count(books_count){} 
		};
		
		int main() {
			Book book1 = {"Owrell", 1984, "1984"};
			Book book2 = {1984};
		
			Person main_author = {65, "Bjarne", "Stroustrup"};
			Person my_author(65, "Bjarne", "Stroustrup");
		
			Library my_lib = 25;
		
			return 0;
		}
//======================  end of sample.cpp  ==========================
                

Каковы преимущества использования конструктора с параметрами перед явной позиционной инициализацией объекта класса?

//====================== start of sample.cpp ==========================
		class Person
		{
			short m_age;
			char* m_name;
			char* m_subname;
		public:
			Person(short age, char* name, char* subname)
			: m_age(age), m_name(name), m_subname(subname){}
		};
		
		class Library
		{
		public:
			long  m_books_count;
			const char* m_name;
			const char* m_city;
		};
		
		int main()
		{
			Library my_lib = {1240, "Main", "DefaultCity"};
			Library *p_lib = new Library;
			Library empty_lib;
		
			Person any_person(25, "Djon","S");
			Person *pother_person = new Person;
		
			return 0;
		}
//======================  end of sample.cpp  ==========================
                

Какие утверждения про конструктор с параметрами верны?

//====================== start of sample.cpp ==========================
		#include <vector>
		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("unknown"){}
		};
		
		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, "Vasily", "Ivanov", 123456);
			return 0;
		}
//======================  end of sample.cpp  ==========================
                

//====================== start of sample.cpp ==========================
		int main()
		{
			Reader readers1[] = {"", ""};
			std::vector readers2;
			Reader reaedr3 = {(22, "Vasily", "Ivanov", 123456), (45, "Alex", "V", 993421) };
			return 0;
		}
//======================  end of sample.cpp  ==========================
                

Для чего могут служить закрытые и защищённые конструкторы?

В каких случаях происходит по членная инициализация объекта класса?

//====================== 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  ==========================
                

Какой из приведённых конструкторов копирования соответствуют канонической форме класса?

//====================== 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  ==========================
                

//====================== 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  ==========================
                

С какими вариантами модификаторов и сигнатур могут быть деструкторы?

Какие операции обычно может выполнять деструктор?

Как в языке С++ поддерживается идиома RAII?

Какие утверждения относительно идиомы RAII верны?

Какие утверждения насчёт явного вызова деструктора верны?

//====================== 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  ==========================
                

Какие операции выполняются в конструкторе?

//====================== start of sample.cpp ==========================
		#include <vector>
		
			class ServiceOrganization;
		
			class Building
			{
				static char* m_city;
				const  unsigned int m_high_size;
				std::vector<int> m_flats;
				unsigned int m_square;
				ServiceOrganization& m_organization;
			public:
			   Building();
			};
		
		int main()
		{
			Building house;
			return 0;
		}
//======================  end of 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  ==========================
                

Чем отличается оператор присваивания от оператора присваивания с переносом?

В каких случаях проявляется проблема множественного наследования?

Каким образом предполагается решать проблему множественного наследования в языке С++?

Какие утверждения насчёт полиморфизма верны?

Какие утверждения насчёт позднего связывания верны?

Какие утверждения насчёт абстрактных и конкретных классов верны?

//====================== 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  ==========================
                

Методы и атрибуты базового класса с каким модификатором доступа доступны классам потомкам?

//====================== start of sample.cpp ==========================
    class Input
    {
    public:
        Input();
    };

    class Output
    {
    public:
        Output();
    };

    class USBInput
    {    };

    class USBOutput
    {
    };

    class SimpleComputer
    {
        long         m_memory;
        const char*  m_processor;
        Input        m_input;
        Output       m_output;

    public:        

        long GetPerformance();
        void Start();
        void Reset();
    };

    class PersonalComputer: public SimpleComputer
    {
        USBInput     m_input;
        UserOutput   m_output;
    };

    class LaptopComputer: public PersonalComputer
    {
        const char*  m_processor;
    public:        
        void Start();
        void Reset();
    };
//======================  end of sample.cpp  ==========================
                

//====================== start of sample.cpp ==========================
		class Computer
		{
		public:
			Computer(OutPutDev& outdev)
			: m_proc("amd64")
			, m_disk2(1024)
			, m_disk1(128)
			, m_mem(4096)
			, m_output(outdev)
			{
				m_pinput = new InputDev();
			}
		private:
			Processor  m_proc;
			HDDDev     m_disk1;
			HDDDev     m_disk2;
			InputDev*  m_pinput;
			OutPutDev& m_output;
			Memory     m_mem;
		};
//======================  end of sample.cpp  ==========================
                

//====================== start of sample.cpp ==========================
		class Input {
		public:
			Input();
		};
		
		class USBInput: public Input {
		public:
			USBInput(): Input() {}
		};
		
		class Device {
		public:
			Device();
		};
		
		class ManualUserDev:  public Device {
		public:
			ManualUserDev() : Device()
			{}
		};
		
		class Keyboard: public USBInput,  public ManualUserDev {
		public:
			Keyboard(): ManualUserDev(), USBInput() {}
		};
//======================  end of 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  ==========================
                

Какие утверждения про виртуальные методы верны?

Какие утверждения про чисто виртуальные методы и абстрактные классы верны?

//====================== start of sample.cpp ==========================
		class Input  {
		public:
			Input();
			~Input();
		};
		
		class USBInput: public Input {
		public:
			USBInput();
			virtual ~USBInput();
		};
		
		class Device {
		public:
			Device();
			~Device();
		};
		
		class USBDevice: virtual public Device {
		public:
		   USBDevice();
		   virtual ~USBDevice();
		};
		
		class ManualUserDev:  public virtual USBInput {
		public:
			ManualUserDev();
			virtual ~ManualUserDev();
		};
		
		class Key {
		public:
			Key();
			~Key();
		};
		
		class Keyboard: public Input,  public Key {
		public:
			Keyboard();
			~Keyboard();
		};
//======================  end of sample.cpp  ==========================
                

Какие операции в языке С++ поддерживают RTTI?

//====================== 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  ==========================
                

Какие утверждения о структуре type_info верны?

Какие утверждения про производительность работы объектно-ориентированных программ на С++ верны?