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

Упражнение 1:

---

Номер 1

Какие парадигмы программирования поддерживает язык C++?

Ответ:

---

Номер 2

Какими средствами поддерживается в языке С++ обобщённое программирование?

Ответ:

---

Номер 3

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

Ответ:

---

Номер 4

Какие преимущества даёт инкапсуляция?

Ответ:

---

Упражнение 2:

---

Номер 1

	//====================== 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 (выше), являются классом в широком смысле этого слова?
Ответ:

---

Номер 2

				//====================== start of sample.h ==========================
				struct S_EMPTY
				{};
				
				struct A
				{
					int i;
					double g;
				};
				
				class B
				{
					long jj;
				public:
					char _str[6];
				private: 
					static char str_4_all[9];
				};

				union mytypes_t {
				  int i;
				  float f;
				} My;
				//======================  end of sample.h  ==========================
                

]]>Доступ к каким из членов класса, описанных в файле sample.h (выше), является закрытым?
Ответ:

---

Номер 3

				//====================== start of sample.h ==========================
				struct S_EMPTY
				{};
				
				struct A
				{
					int i;
					double g;
				};
				
				class B
				{
					long jj;
				public:
					char _str[6];
				private: 
					static char str_4_all[9];
				};
				
				union mytypes_t {
				  int i;
				  float f;
				} My;
				//======================  end of sample.h  ==========================
                

]]>Доступ к каким из членов класса, описанных в файле sample.h (выше), является открытым?
Ответ:

---

Упражнение 3:

---

Номер 1

				//====================== 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 валидны?
Ответ:

---

Номер 2

				//====================== start of sample.cpp ==========================
				struct A {};
				struct B;
				
				struct B *pb = new B;
				struct A *pa = new A;
				struct B b = *pb;
				
				class C
				{
					struct B m_b;
				};
				
				class D
				{
					struct A m_a;
				};
				//======================  end of sample.cpp  ==========================
                

]]>Какие присвоения и объявления в файле sample.cpp валидны?
Ответ:

---

Номер 3

				//====================== start of sample.cpp ==========================
				class User {};
				class Bank {} my_bank;
				
				class User my_user;
				
				class Bank *pMyBank = &my_bank;
				
				class Bank& rBank = &my_bank;
				
				User *const &prUser = &my_user;
				
				User& secondUser = &my_user;
				//======================  end of sample.cpp  ==========================
                

]]>Какие присвоения и объявления в файле sample.cpp валидны?
Ответ:

---

Номер 4

				//====================== start of sample.cpp ==========================
				class MyAClass 
				{
				public:
					const MyAClass& getMe() const
					{
						return *this;
					}
				};
				
				MyAClass *myAFactory1 = new MyAClass();
				MyAClass myAFactory2;
				
				MyAClass *myA1 = myAFactory1->getMe();
				MyAClass myA2 = myAFactory1->getMe();
				MyAClass const &myA3 = myAFactory1->getMe();
				MyAClass &myA4 = myAFactory1->getMe();
				
				MyAClass const &myA5 = myAFactory2.getMe().getMe();
				//======================  end of sample.cpp  ==========================
                

]]>Какие присвоения и объявления в файле sample.cpp валидны?
Ответ:

---

Упражнение 4:

---

Номер 1

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

Ответ:

---

Номер 2

Какие операции можно делать с ссылками?

Ответ:

---

Номер 3

На что распространяется константность константного объекта класса?

Ответ:

---

Упражнение 5:

---

Номер 1

		//====================== start of sample.cpp ==========================
		class User 
		{
		public:
			const char* name;
			inline int age;
		private:
			volatile double balance;
			mutable char* job_name;
		protected:
			long long phone_number;
			static int phone_prefix = 499;
		};
		//======================  end of sample.cpp  ==========================
                

]]>Какие атрибуты класса User объявлены корректно?
Ответ:

---

Номер 2

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

]]>Какие методы класса User объявлены корректно?
Ответ:

---

Номер 3

		//====================== 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->age;  }
			
			double get_balance() const
			{    return (*this)->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  ==========================
                

]]>В каких методах обращения к членам объекта класса user типа User корректны?
Ответ:

---

Упражнение 6:

---

Номер 1

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

Ответ:

---

Номер 2

Каких областей видимости нет в языке С, но есть в С++?

Ответ:

---

Номер 3

		//====================== start of sample.cpp ==========================
		class Program 
		{
		public:
			static char* country;
			static const int version = 5;
			static short buid_num = 2223;
			static char* name;
			static long long date;
		};
		
		Program prog;
		//======================  end of sample.cpp  ==========================
                

]]>Какие объявления и обращения к членам класса и объекта prog, типа Program в файле sample.cpp корректны?
Ответ:

---

Упражнение 7:

---

Номер 1

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

Ответ:

---

Номер 2

		//====================== start of sample.cpp ==========================
		volatile unsigned long idx;
		volatile double times[16];
		struct Program 		{
			double proc_time;
			long long mem_size;
			long long threads[20];
		};
		
		int main()		{
			volatile Program prg;
			long my_idx = idx;
			double my_time1 = times[1];
			double pmy_time5 = dynamic_cast<double*>(×[5]);
			double *pmy_time10 = const_cast<double*> (×[10]);
			Program *pmy_prog = static_cast<Program*>(&prg);
			long long* pmy_thread3 = const_cast<long long*>(&prg.threads[3]);
			return 0;
		}
		//======================  end of sample.cpp  ==========================
                

]]>Присвоения значений каким переменным в файле sample.cpp корректны?
Ответ:

---

Номер 3

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

Ответ:

---

Номер 4

В каких из приведённых ниже выражений нельзя обойтись без указателя this?

Ответ:

---

Упражнение 8:

---

Номер 1

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

Ответ:

---

Номер 2

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

]]>Какие из методов являются встроенными и объявлены корректно?
Ответ:

---

Номер 3

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

]]>При присвоении значений каким переменным в файле sample.cpp корректно используются корректно определённые методы?
Ответ:

---

Упражнение 9:

---

Номер 1

Чем отличаются статические методы класса от нестатических?

Ответ:

---

Номер 2

		//====================== start of sample.cpp ==========================
		class Program 
		{
			static char* prog_name;
			volatile long threads_count;
			mutable double time_of_work;
			long version;
		public:
		   static char* get_name()
		   { return prog_name; }
		
		   long* getthreadscount()
		   { return &threads_count; }
		
		   volatile long* get_threads_count() 
		   { return &threads_count; }
		
		   static double get_time_of_work()
		   { return time_of_work; }
		
		   volatile long get_version()
		   { return version; }
		};
		//======================  end of sample.cpp  ==========================
                

]]>Какие методы в файле sample.cpp корректно обращаются к членам класса?
Ответ:

---

Номер 3

		//====================== start of sample.cpp ==========================
		class Program 
		{
			char* prog_name;
		public:
			long threads_count;
			double time_of_work;
			long version;
		};
		const Program& get_my_program();
		
		int main()
		{
			Program& prg = const_cast(get_my_program());
		
			long Program::*pmy_thr_count = &Program::threads_count;
			long my_threads_1 = *pmy_thr_count;
			long my_threads_2 = prg.*pmy_thr_count;
			long Program::*pversion = &Program::version;
			long my_version = (&prg)->*pversion;
			char* Program::*pmy_name = &Program::prog_name;
			char* my_name = prg.*pmy_name;
			return 0;
		}
		//======================  end of sample.cpp  ==========================
                

]]>Какие присвоения значений членов класса переменным будут успешны в файле sample.cpp?
Ответ:

---

Номер 4

		//====================== start of sample.cpp ==========================
		class Program 
		{
			long threads_count;
			double time_of_work;
		public:
			char* prog_name;
			long version;
			long get_threads_count();
			double get_time_of_work();
		};
		const Program& get_my_program();
		typedef double (Program::*my_getter)();
		
		int main()
		{
			long Program::*pversion = &Program::version;
			char* Program::*pmy_name = &Program::prog_name;
		
			long (Program::*f_threads_count)() = &Program::get_threads_count;
			Program& prg = const_cast<Program&>(get_my_program());
			long my_version = (prg)->*pversion;
		
			char* my_name = prg.*pmy_name;
			long my_threads_count = (prg.f_threads_count)();
			my_getter getter = &Program::get_time_of_work;
			double my_time_of_work = (prg.*getter)();
			return 0;
		}
		//======================  end of sample.cpp  ==========================
                

]]>Какие присвоения значений членов класса переменным будут успешны в файле sample.cpp?
Ответ:

---

Упражнение 10:

---

Номер 1

Какие утверждения насчёт дружественных отношений в С++ 	верны?

Ответ:

---

Номер 2

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

]]>Для каких функций и методов корректно организован доступ к членам класса Program файле sample.cpp?
Ответ:

---

Номер 3

Что необходимо сделать для реализации потокового ввода-вывода для своего класса?

Ответ:

---

Упражнение 11:

---

Номер 1

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

Ответ:

---

Номер 2

		//====================== start of sample.cpp ==========================
		union Lesson
		{
			long math_lection_number;
			short home_work_number;
		} my_lesson;
		
		class Lection
		{
		public:
			union 
			{
				char* proffesor;
				short       graduate_number;
			} main_person;
		
		   union
		   {
				short home_work_task;
				char *home_book_name;
		   };
		};
		
		int main()
		{
			Lesson* pmy_lesson = &my_lesson;
			Lection my_lection;
		
			long lection = my_lesson.math_lection_number;
			short* phome_work = &(pmy_lesson->home_work_number);
			char* proffesor = my_lection.proffesor;
			short gr_number = my_lection.main_person.graduate_number;
			short my_task = Lection::home_work_task;
			const char * my_book = my_lection.home_book_name;
			return 0;
		}
		//======================  end of sample.cpp  ==========================
                

]]>Присвоение данных класса каким переменным выполнено корректно (т.е. данные объявлены корректно и доступ к ним так же корректен) файле sample.cpp?
Ответ:

---

Номер 3

		//====================== 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?
Ответ:

---

Номер 4

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

Ответ:

---