<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>FulcrumWeb</title>
	<atom:link href="http://www.fulcrumweb.com.ua/feed" rel="self" type="application/rss+xml" />
	<link>http://www.fulcrumweb.com.ua</link>
	<description>Все для карьеры  программиста</description>
	<lastBuildDate>Thu, 16 Feb 2012 14:02:11 +0000</lastBuildDate>
	<language>en</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>http://wordpress.org/?v=3.3</generator>
		<item>
		<title>Техническое интервью юниор программиста: устная часть</title>
		<link>http://www.fulcrumweb.com.ua/archives/2413</link>
		<comments>http://www.fulcrumweb.com.ua/archives/2413#comments</comments>
		<pubDate>Thu, 16 Feb 2012 08:28:03 +0000</pubDate>
		<dc:creator>galina</dc:creator>
				<category><![CDATA[Собеседование: Советы]]></category>
		<category><![CDATA[Начинающий программист]]></category>
		<category><![CDATA[Собеседование]]></category>
		<category><![CDATA[Советы]]></category>

		<guid isPermaLink="false">http://www.fulcrumweb.com.ua/?p=2413</guid>
		<description><![CDATA[Автор: Галина Мирошниченко координатор учебных программ компании Fulcrumweb Cтатьи с советами о том, как проходить собеседования встречаются в изобилии, но речь в них идет чаще всего о рекомендациях, которые не зависят от профессии и годятся в первую очередь для HR-интервью. Наверное, все знают, что нужно сначала правильно составить резюме, а перед собеседованием умыться-побриться, прийти вовремя [...]]]></description>
			<content:encoded><![CDATA[<h4>Автор: Галина Мирошниченко </h4>
<p><strong><em>координатор учебных программ компании Fulcrumweb</em></strong></p>
<p>Cтатьи с советами о том, как проходить собеседования встречаются в изобилии, но речь в них идет чаще всего о рекомендациях, которые не зависят от профессии и годятся в первую очередь для HR-интервью.</p>
<p>Наверное, все знают, что нужно сначала правильно составить резюме, а перед собеседованием умыться-побриться, прийти вовремя и не грубить менеджеру по персоналу. А еще нужно сформулировать план карьеры до самой старости и уметь рассказывать о своих недостатках, как о достоинствах. Обычно этот этап, так или иначе, преодолевается, и дело доходит до технического собеседования. Вот о том, как его проходить, и пойдет дальше речь.</p>
<p>За полтора года работы в компании среднего размера я провела более 200 первичных технических интервью с претендентами на позиции начинающих разработчиков по C++ и C#. Накоплен определенный опыт и им хочется поделиться, в надежде на то, что <strong> эти советы помогут кому-то правильно подготовиться и получить первую работу.</strong></p>
<div class='et-learn-more clearfix'>
					<h3 class='heading-more'><span>Загляните по другую сторону баррикады</span></h3>
					<div class='learn-more-content'>Исходите из того, что технические интервьюеры – это вполне адекватные люди, которые обычно знают, чего хотят и их время весьма высоко стоит, поэтому интервью – это не то место, где можно просто поболтать на общие темы по поводу технологий программирования. Обычно ожидается двухстороннее общение на конкретные темы, в рамках которого обеими сторонами задаются конкретные вопросы и даются конкретные ответы. Интервью будут продолжать ровно до того момента, пока у интервьюера не сформируется одно из решений в троичной логике: ДА/НЕТ/ПОДОЖДАТЬ С РЕШЕНИЕМ.</div>
				</div>
<div class='et-learn-more clearfix'>
					<h3 class='heading-more'><span>Задавайте вопросы по ходу дела</span></h3>
					<div class='learn-more-content'><p>Не кидайтесь сразу давать ответ, если что-то недопоняли или сомневаетесь, лучше спросите. Чтобы понять, о чем идет речь, приведу пример из собственного опыта. Однажды на интервью меня попросили на бумаге написать некий SQL-запрос, который вроде был понятен по формулировке, но сложность его реализации с моей точки зрения явно выходила за разумные рамки того, что можно делать на бумаге. После изрядных усилий и затрат времени запрос был написан, но результат весьма удивил собеседующего. Мы начали объясняться, и выяснилось, что при формулировке условия он пропустил (или я недослышала) два слова, которые упрощали задачу в разы. Такая ситуация неприятна обеим сторонам и ее вполне можно было бы избежать, если бы соискатель не кинулся в бой очертя голову, а сначала бы проговорил, как он понял задачу, и что собирается делать.</div>
				</div>
<div class='et-learn-more clearfix'>
					<h3 class='heading-more'><span>“Я знаю” или “Google знает”</span></h3>
					<div class='learn-more-content'>Обычно присутствует два уровня того, что оценивается – владение неким необходимым набором конкретных знаний и общее умение соображать (иначе креативность) при решении новых задач. Здесь имеется некое противоречие, которое обычно собеседуемый, если не знает о чем идет речь, озвучивает примерно так “… в Google все есть…”. И, слава богу, что есть, это интервьюер и без вас знает, но он же не Google собеседует. Вряд ли вы со своей позиции переубедите интервьюера, если он считает, что ответ на конкретный вопрос нужно брать из головы, а не из Google, даже если это вопрос на чистые знания. Поэтому лучше высказывать свои соображения, идеи, видение подходов. В конце концов, можно просто ответить “не знаю” – в разумном количестве такие ответы вполне допустимы и не являются фатальными. А в некоторых случаях честное “не знаю” – это лучший выбор, который нами весьма приветствуются, особенно если альтернативой будут плавающие мысли по поводу явно незнакомых вещей.
Более того, грамотно построенное интервью обычно проводится таким образом, что при обсуждении конкретной темы интервьюер задает ряд логически взаимосвязанных вопросов, начиная простыми и заканчивая все более сложными, чтобы в идеале дойти до ответа “… ну тут я уже не знаю – ого куда забрались…”.</p>
<p></div>
				</div>
<div class='et-learn-more clearfix'>
					<h3 class='heading-more'><span>Это мы не проходили, это нам не задавали</span></h3>
					<div class='learn-more-content'>Любимая песенка студентов. Ее перепевы слышны на всех экзаменах и зачетах. Еще на экзаменах часто говорят, что я это обязательно выучу, только вот как раз сейчас, на экзамене, очень нужно, чтобы Вы мне поверили на слово. Кому и насколько это помогло сдавать экзамены – каждый сам знает.</p>
<p>Но собеседование – это не экзамен по самой своей сути, так как оценка на экзамене не связана для преподавателя ни с какими рисками, а риски, связанные с издержками из-за принятия некомпетентного сотрудника весьма ощутимы. Незнание вами чего-либо – это на этапе собеседования ваша проблема, но если вы станете сотрудником компании – то это станет проблемой компании. И перекладывать вашу проблему на свои плечи компания готова в минимальных четко осознанных пределах. Причины возникновения этой проблемы вообще редко кого-то интересуют, а то, насколько быстро вы можете ее решить, восполнив пробелы в знаниях, проверить на интервью затруднительно, поэтому аргументы “… легкообучаемый, усидчивый, старательный…” чаще всего должного эффекта не возымеют.</div>
				</div>
<div class='et-learn-more clearfix'>
					<h3 class='heading-more'><span>Я знаю много технологий и очень много языков...</span></h3>
					<div class='learn-more-content'>Да, в вузе вам читали много всякого – семестр того, семестр сего. Беда в том, что в результате большая часть знаний, полученных только в рамках вузовской программы, находится чуть выше уровня “Hello, World ”, чего, как вы сами понимаете, недостаточно, для того, чтобы приступить к работе. У Вас должна быть основная связка технологий, по которой вы в первую очередь позиционируете себя как специалиста. По ней Вы должны знать гораздо больше стандартных институтских лабораторных. Насколько больше &#8211; для каждого конкретного случая не угадаешь, но основные синтаксические конструкции, главные классы, стандартные контейнеры и их различия, управление памятью, &#8211; все это вы должны быть готовы обсуждать на словах. Если вы определились с основной технологией, то в процессе учебы старайтесь, везде, где у Вас есть право выбора, именно ее и применять, продвигаясь с каждым новым проектом все глубже и набирая необходимый практический опыт. Изучая альтернативные технологии, постарайтесь сформировать представление, что в них является общим, а где таятся принципиальные различия (яркий пример таких различий – управление памятью в C++ и C#).</div>
				</div>
<div class='et-learn-more clearfix'>
					<h3 class='heading-more'><span>ООП оно и в Африке ООП</span></h3>
					<div class='learn-more-content'>Если Вы выбрали технологию, в основе которой лежит объектно-ориентированный язык программирования, то вы, безусловно, должны понимать, уметь четко объяснять словами и применять на практике концепции ООП. Не ограничивайтесь использованием ООП подходов, только в тех предметах, где этого требует преподаватель в явном виде. Применяйте ООП везде в своих проектах по собственной воле и выбору, где это уместно. Прочитайте на эту тему какую-нибудь классическую книгу. Решите самостоятельно несколько заданий на проектирование структуры классов и сравните результаты вашего решения с ответом. Вы наберете много зачетных баллов на собеседовании, если на практически неизбежные вопросы по ООП для примера расскажите что-то более оригинальное, чем иерархия классов для геометрических фигур.</div>
				</div>
<div class='et-learn-more clearfix'>
					<h3 class='heading-more'><span>У вас не может не быть опыта работы, если вы окончили компьютерную специальность в вузе</span></h3>
					<div class='learn-more-content'>“Вы не можете идти на собеседование в нормальную компанию, если у вас нет опыта работы”. Это утверждение, безусловно, истинно и многие студенты, которые ищут свою первую работу, часто рассматривают подобную ситуацию как полный тупик. Происходит это в основном, из-за того, что смешиваются два понятия: ОПЫТ и КОММЕРЧЕСКИЙ ОПЫТ. Варианты бывают разные, но самый массовый – это бакалавр компьютерной или околокомпьютерной специальности, у которого просто не может не быть такого опыта, если он учился в вузе, преследуя цель стать программистом, так как неизбежно делал лабораторные, курсовые и защитил (или защитит) в диплом в конце концов. Конечно, не секрет, что сейчас наиболее распространен вариант, когда эти задания студент самостоятельно не делает, но это же не ваш случай!</p>
<p>Да, такой опыт программирования является академическим, и качество разработанных программ никто особенно не проверял. Да и написаны они чаще всего в стиле “студент”, который, к сожалению, почти всегда разительно отличается от стиля “разработчик” (об этом будет подробно рассказано в отдельном посте). Так ведь никто не мешает вам делать свои институтские проекты по-взрослому – было бы желание. В любом случае, что-то вы программировали и, как говорится, чем богаты, тем и рады.</div>
				</div>
<div class='et-learn-more clearfix'>
					<h3 class='heading-more'><span>Если опыта работы действительно нет, нужно сделать так, чтобы он был</span></h3>
					<div class='learn-more-content'>Чаще всего это бывает, если специальность не компьютерная или вы ощущаете, что уровень вуза все же недостаточен. Тогда проекты для учебы нужно найти самостоятельно. Это может быть реализация какой-то вашей собственной идеи, Open Source проекты, фриланс – да что угодно. Сделайте один-два проекта, так, чтобы результат Вам понравился, и было бы приятно рассказывать о них другим людям.</div>
				</div>
<div class='et-learn-more clearfix'>
					<h3 class='heading-more'><span>Нужно быть готовым рассказать об учебных проектах</span></h3>
					<div class='learn-more-content'>И ведь именно эту часть интервью можно подать в самом выигрышном свете – тут вы на своей территории, можете заранее целенаправленно подготовиться, заинтересовать и даже блеснуть какими-то изюминками. Совсем хорошо, если будет подготовлена демонстрация. Только тогда все должно работать как часы. Если что-то глючит, отваливается или недоделано, то демонстрация только навредит. Рассказывая о работе в коллективных Open Source проектах, нужно быть готовым четко ответить на вопрос «А что сделали лично Вы?»</p>
<p>Но можно именно в этой части интервью и провалиться, причем вы даже это не готовы заметить. Если на вопрос о том, какая же задача решалась в курсовой работе, дается ответ “… не помню, давно это было, &#8211; аж три месяца назад…”, то дальше проводить интервью становится уже не интересно.</div>
				</div>
<div class='et-learn-more clearfix'>
					<h3 class='heading-more'><span>Общайтесь так, чтобы вас понимали</span></h3>
					<div class='learn-more-content'>За этим нужно специально следить, потому что таких навыков современное высшее образование уже давно массово не дает, а классический неторопливый устный экзамен по курсам, связанным с ИТ, практически канул в лету. Стройте грамматически законченные предложения, употребляйте правильные термины, избегая жаргона, который, возможно, и поймут, но не всегда оценят. Фраза «… и тогда я разрулил трабл с перфомансом, для чего прикрутил эту либу к этой фиговине …» гораздо лучше формулируется так: «… и тогда я решил проблему производительности, для чего использовал такую-то библиотеку в своем проекте…». Следует иметь в виду, что в техническом интервью на той или иной стадии участвует ваш непосредственный будущий начальник. Его мнение имеет зачастую решающее значение. И для него жизненно важно, чтобы вы понимали его, а он понимал ход ваших мыслей, ваши идеи и проблемы.</p>
<p>Незнание конкретных особенностей технологии зачастую менее критично, чем неумение доносить свои мысли до собеседника. Аргумент типа “…я как та собака понимаю, но сказать не могу… ”, который очень часто приходится слышать от студентов, в командной работе благополучно заведет в тупик. Да, в процессе реальной работы многое будет формулироваться письменно, кому-то так, безусловно, проще, но на интервью это невозможно. Достаточно частая причина отрицательного решения состоит именно в том, что вас не понимают, особенно, когда вы рассказываете о своих проектах. “Я не понял, какая задача решалась в бакалаврской работе и как она решалась” – и все, решение будет отрицательным. Причем вы сами даже не осознаете, скорее всего, что именно это и было основной причиной отказа.</div>
				</div>
<div class='et-learn-more clearfix'>
					<h3 class='heading-more'><span>Не употребляйте о себе слова с негативным и расплывчатым смыслом</span></h3>
					<div class='learn-more-content'><p>Избегайте оборотов-оправданий похожих на такие: “… у нас лабы были на низком уровне…”, “… у меня сломался компьютер…”, “…да я вообще-то ерунду программировал…”. Очень часто соискатели по собственной инициативе озвучивают что-то в таком духе. Апофеоз подобного стиля беседы продемонстрировал соискатель, который зачем-то рассказал о том, как он потерял флешку с текстом и кодом дипломного проекта за два дня до защиты. Что в этом случае должен подумать его потенциальный непосредственный начальник, который проводил собеседование? Только то, что человек неорганизован и несерьезно относится к серьезным вещам. Угадайте, нужен ли ему такой сотрудник?</p>
<p>Еще одно коварное слово “читал”. Как прикажете вас понимать, если на конкретный вопрос: “ знаете ли вы что такое синглетон?” дается ответ «… я об этом читал …». В умении соискателя читать никто не сомневается. Может быть, за Вашим ответом стоит полное понимание этого паттерна и знание нескольких вариантов его потокобезопасной реализации с их достоинствами и недостатками, а может быть, Вы думаете, что это город в Австралии (есть такой). Упомянуть о том, что вы читали что-то дополнительное на тему вопроса, безусловно, можно, но только после того, как вы обозначили свое собственное видение предмета и хоть что-то рассказали по существу.</p></div>
				</div>
]]></content:encoded>
			<wfw:commentRss>http://www.fulcrumweb.com.ua/archives/2413/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Чем &#8220;студенческий&#8221; код отличается от коммерческого?</title>
		<link>http://www.fulcrumweb.com.ua/archives/2499</link>
		<comments>http://www.fulcrumweb.com.ua/archives/2499#comments</comments>
		<pubDate>Thu, 16 Feb 2012 07:50:17 +0000</pubDate>
		<dc:creator>galina</dc:creator>
				<category><![CDATA[Собеседование: Советы]]></category>
		<category><![CDATA[Начинающий программист]]></category>
		<category><![CDATA[Собеседование]]></category>
		<category><![CDATA[Советы]]></category>

		<guid isPermaLink="false">http://www.fulcrumweb.com.ua/?p=2499</guid>
		<description><![CDATA[Автор: Галина Мирошниченко координатор учебных программ компании Fulcrumweb Чем же студенческий программный код отличается от коммерческого? Ответ на этот вопрос с технической точки зрения весьма пространен и содержится в многочисленных книгах и руководствах, а с житейской точки зрения разница, по-моему, состоит в том в следующем: Студенческий код пишется для того, чтобы решить только свои проблемы [...]]]></description>
			<content:encoded><![CDATA[<h4>Автор: Галина Мирошниченко </h4>
<p><strong><em>координатор учебных программ компании Fulcrumweb</em></strong></p>
<p>Чем же студенческий программный код отличается от коммерческого? Ответ на этот вопрос с технической точки зрения весьма пространен и содержится в многочисленных книгах и руководствах, а с житейской точки зрения разница, по-моему, состоит в том в следующем:</p>
<p>Студенческий код пишется для того, чтобы решить только <strong>свои проблемы</strong> (получить оценку). Коммерческий же код пишется для того, чтобы решить <strong>проблемы других людей</strong> (заказчиков), не создавая при этом особых проблем третьим людям (коллегам). И только после этого можно рассчитывать на решение своих проблем (получение зарплаты).</p>
<p>Студенческий код пишется так, чтобы от автора <strong>отстали как можно быстрее</strong>, по принципу сдал – забыл. Коммерческие программы, раз за них платят, очевидно, нужны еще кому-то кроме самого автора и пишутся они обычно с прицелом на <strong>продолжение сотрудничества,</strong> особенно если заказчик вас устраивает.</p>
<p>Студенческий <strong>код чаще всего не видит никто,</strong> кроме автора. В лучшем случае его посмотрит компетентный преподаватель, но его желание добиться от вас выполнения лабораторной на нормальном уровне основано только на его личной добросовестности, внешней мотивации на это преподаватель не имеет. С коммерческим кодом юниора все наоборот: его будет проверять ваш непосредственный начальник, его будут стыковать с остальной частью проекта, им будут заниматься инженеры по качеству, в конце концов, им будет пользоваться заказчик. От всех этих людей вышеупомянутый юниор зависит весьма сильно, и все они имеют собственный интерес, чтобы с этим <strong>кодом все было “как надо”.</strong> И это “как надо” для коммерческого кода обычно достаточно четко описано. Поэтому, один из первых документов, которые вы прочитаете, придя на работу – это Code Convention (Конвенция по написанию кода) конкретной организации.</p>
<p>Если вы учитесь в вузе не с целью просто получить диплом “… a дальше видно будет…”, но приняли решение стать таки программистом, &#8211; то отнеситесь к своим <strong> учебным институтским программам как к коммерческому продукту,</strong> который вы в перспективе обменяете на предложение той работы и условий, которые выберете вы сами. Ведь это, согласитесь, лучше, чем работа, полученная по принципу “…куда возьмут…”.</p>
<p>Не является секретом, что в процессе собеседований часто возникает просьба или даже требование показать примеры своего кода. Человек, который будет их просматривать, обычно не имеет времени и возможности разобраться в деталях постановки вашей задачи с зачастую незнакомой для него предметной областью, но он знает, <strong>как не надо программировать</strong> на уровне общеизвестных требований. Может быть, в вашем курсовом проекте скрывается оригинальная реализация сложного алгоритма, которую вы придумали сами, но вряд ли найдется талант, способный вычленить эту изюминку за разумное (очень небольшое) время в массе неформатированного кода без комментариев, втиснутого в единственный огромный файл.</p>
<p>Существуют некие <strong>общепринятые правила написания промышленного кода</strong>, о которых студентам рассказывают далеко не всегда. К сожалению, не практикующие преподаватели о них зачастую сами не знают, а если и знают – то важности не осознают, поскольку не прочувствовали на собственной шкуре. Так ведь это и не архисложно &#8211; прочитайте стандартные материалы с подобными рекомендациями и привыкайте следовать им в приемлемом объеме по собственной воле и разумению, даже если от вас это не требуют преподаватели. А уж если требуют – так, поверьте, что таких преподавателей стоит слушать. Например, <a title="Хороший стиль кода" href="http://www.fulcrumweb.com.ua/archives/1834#goodstylecode" target="_blank">вот хорошие материалы по поводу стиля написания кода.</a></p>
<p>К сожалению, зачастую, если даже преподаватель указывает на вопиющие стилевые ошибки, то заставить их исправить обычно не удается, потому что, против аргумента <strong> “Так ведь работает!”</strong> преподавателю спорить себе дороже. Мой личный опыт подобной войны со студентом, который имел четкую цель стать программистом и САМ писал программы, окончился полным моим поражением. Например, я требовала применить оператор цикла и исправить то место, где 17! раз подряд вызывался один и тот же метод и ему передавался инкрементированный 17 раз параметр. И там было много еще всякого в таком же духе. Время шло, мы вели дебаты, я выслушивала аргументы в духе: “Ну что Вы, конечно, я знаю оператор цикла, и, конечно, на работе так писать не буду – <strong>но мы же в вузе, а тут чего придираться&#8230;</strong>”. И он меня уговорил – зачет был вовремя сдан, хотя стороны остались при своем мнении. Излишне говорить, что увидев бы код подобного РАБОТАЮЩЕГО! проекта, прикрепленный к резюме на должность начинающего NET-разработчика, соискатель получил бы от меня ответ “Спасибо, мы получили Ваше резюме и занесли сведения в базу данных&#8230;” Приглашения на собеседование не поступило бы.</p>
<p>Еще пример. Начало бакалаврской работы. Задается вопрос – <strong>делаем по взрослому, или чтобы защититься?</strong> Конечно, по взрослому. Тогда читайте вот эти материалы по поводу общих правил кодирования. &#8220;Прочитали?&#8221; &#8220;Да.&#8221; Начинаем писать первый код – разбираемся, как работают вот эти классы и можно ли на них основывать реализацию основного функционала. Имеем в результате: Form1 c TextBox1, TextBox2 и т. д. “Вроде же вы прочитали, о том, что переменным нужно давать смысловые имена?” “А, ну да, так я думал, что это ПОТОМ когда-нибудь понадобится&#8230; Ну ладно, я ПОТОМ переименую&#8230;”</p>
<p>Беда в том, что когда наступает это заветное ПОТОМ, и вы начинаете ходить на собеседования, – вам все эти правила придется вспоминать и сходу применять с непредсказуемыми результатами. А переделывать свои проекты, написанные в студенческом стиле, так, чтобы их код можно было бы показывать посторонним компетентным людям вы, и подавно, не соберетесь. Поэтому, чем раньше вы осознаете, будете постоянно держать в голове, и применять правила коммерческого программирования, тем лучше, в конечном итоге для вас самих.</p>
]]></content:encoded>
			<wfw:commentRss>http://www.fulcrumweb.com.ua/archives/2499/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Recruiter/Junior Recruiter</title>
		<link>http://www.fulcrumweb.com.ua/archives/2626</link>
		<comments>http://www.fulcrumweb.com.ua/archives/2626#comments</comments>
		<pubDate>Thu, 09 Feb 2012 17:45:08 +0000</pubDate>
		<dc:creator>galina</dc:creator>
				<category><![CDATA[Вакансии]]></category>

		<guid isPermaLink="false">http://www.fulcrumweb.com.ua/?p=2626</guid>
		<description><![CDATA[В связи с планомерным стабильным расширением компания «FulcrumWeb» приглашает на постоянную работу специалиста по подбору персоналаPosition code: [Recruiter]Number of vacancies: 1Closing period: February 2012 Основные требования Законченное высшее образование (техническое или гуманитарное) Высокие коммуникационные навыки: хорошие способности ясно излагать свои мысли; грамотно, дипломатично и вежливо переписываться на русском языке Знание английского языка на уровне не [...]]]></description>
			<content:encoded><![CDATA[<p>В связи с планомерным стабильным расширением компания «FulcrumWeb» приглашает на постоянную работу специалиста по подбору персонала<br />Position code: <strong>[Recruiter]</strong><br />Number of vacancies: <strong>1</strong><br />Closing period: February 2012</p>
<p><strong>Основные требования</strong></p>
<ul>
<li>Законченное высшее образование (техническое или гуманитарное)</li>
<li>Высокие коммуникационные навыки: хорошие способности ясно излагать свои мысли; грамотно,  дипломатично и вежливо переписываться на русском языке</li>
<li>Знание английского языка на уровне не ниже Intermediate</li>
<li>Опытный пользователь ПК: почтовые программы, поисковые системы, MS Word, Excel</li>
<li>Опыт использования социальных сетей – linkedin, moikrug, odnoklassniki, facebook</li>
<li>Желательно знакомство с базовыми терминами из мира программирования (языки программирования, база данных)</li>
<li>Предпочтение кандидатам отдается при наличии опыта работы рекрутером не менее 1-го года, но будут рассмотрены и мотивированные кандидаты  без  опыта работы</li>
</ul>
<p><strong>Основные обязанности</strong> </p>
<ul>
<li>первичный поиск претендентов для закрытия вакансий в нашей компании;</li>
<li>активная работа с социальными сетями;</li>
<li>участие в HR-событиях, представляющих интерес для компании;</li>
</ul>
]]></content:encoded>
			<wfw:commentRss>http://www.fulcrumweb.com.ua/archives/2626/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Морской бой</title>
		<link>http://www.fulcrumweb.com.ua/archives/2566</link>
		<comments>http://www.fulcrumweb.com.ua/archives/2566#comments</comments>
		<pubDate>Fri, 27 Jan 2012 12:37:26 +0000</pubDate>
		<dc:creator>galina</dc:creator>
				<category><![CDATA[ООП]]></category>
		<category><![CDATA[Задача на 1 час]]></category>

		<guid isPermaLink="false">http://www.fulcrumweb.com.ua/?p=2566</guid>
		<description><![CDATA[Реализовать структуру классов для игры морской бой по стандартным правилам со следующими изменениями в поведении кораблей • Корабль может плавать и стрелять. За один ход один кораблей либо делает выстрел, либо перемещается. • Стрельба производится всеми неповрежденными палубами корабля. Цель задается для одной указанной палубы. Указанная палуба стреляет в цель. Выстрелы других палуб накрывают клетки [...]]]></description>
			<content:encoded><![CDATA[<p><span class='et-dropcap'><img src="http://www.fulcrumweb.com.ua/ukr/wp-content/uploads/2012/01/SeaBattlePost1.jpg" alt="Морской бой" height="96" width="127"/></span><strong> Реализовать структуру классов для игры <a title="Игра морской бой" href="http://ru.wikipedia.org/wiki/Морской бой" target="_blank">морской бой по стандартным правилам</a> со следующими изменениями в поведении кораблей </strong></p>
<p>
•	Корабль может плавать и стрелять. За один ход один кораблей либо делает выстрел, либо перемещается.<br />
•	Стрельба производится  всеми неповрежденными палубами корабля. Цель задается для одной указанной палубы. Указанная палуба стреляет в цель. Выстрелы других палуб накрывают клетки вражеской акватории так, как определено конфигурацией выстрелившего корабля – см. рисунок.<br />
•	Корабль  может перемещаться на одну клетку вправо/влево/вверх/вниз, оставаясь в пределах акватории. При этом палубы разных кораблей не могут занимать одну и ту же клетку акватории. Могут ли корабли соприкасаться, и каким образом – на ваше усмотрение.<br />
•	Корабль, у которого подбита хоть одна палуба, передвигаться не может, но может стрелять.<br />
•	Полностью подбитый корабль тонет, – на его место может со временем приплыть другой корабль.</p>
<p><img src="http://www.fulcrumweb.com.ua/ukr/wp-content/uploads/2012/02/SeaBattlePost.png" alt="Морской бой"  height="379" width="626"/></p>
]]></content:encoded>
			<wfw:commentRss>http://www.fulcrumweb.com.ua/archives/2566/feed</wfw:commentRss>
		<slash:comments>2</slash:comments>
		</item>
		<item>
		<title>Проверка сбалансированности B-дерева: Решение</title>
		<link>http://www.fulcrumweb.com.ua/archives/2401</link>
		<comments>http://www.fulcrumweb.com.ua/archives/2401#comments</comments>
		<pubDate>Tue, 17 Jan 2012 18:27:49 +0000</pubDate>
		<dc:creator>galina</dc:creator>
				<category><![CDATA[Деревья и графы]]></category>
		<category><![CDATA[Приведено решение]]></category>
		<category><![CDATA[Язык C#]]></category>
		<category><![CDATA[Язык C++]]></category>

		<guid isPermaLink="false">http://www.fulcrumweb.com.ua/?p=2401</guid>
		<description><![CDATA[Реализовать функцию, которая проверяет, является ли бинарное дерево сбалансированным. //Структура узла // C++ C# struct tree_node public class Node &#123; &#123; tree_node* left; public Node Left; tree_node* right; public Node Right; int data; public int Data; &#125; &#125; //Сигнатура функции на C++ bool isBalanced&#40;tree_node* root&#41; &#123; //... Посмотрите пост, связанный с этой задачей]]></description>
			<content:encoded><![CDATA[<p>Реализовать функцию, которая проверяет, является ли бинарное дерево сбалансированным.</p>

<div class="wp_syntax"><div class="code"><pre class="cpp" style="font-family:monospace;"><span style="color: #666666;">//Структура узла</span>
<span style="color: #666666;">//    C++                                           C#</span>
<span style="color: #0000ff;">struct</span> tree_node                              <span style="color: #0000ff;">public</span> <span style="color: #0000ff;">class</span> Node
<span style="color: #008000;">&#123;</span>                                             <span style="color: #008000;">&#123;</span>
    tree_node<span style="color: #000040;">*</span> left<span style="color: #008080;">;</span>                             <span style="color: #0000ff;">public</span> Node Left<span style="color: #008080;">;</span>
    tree_node<span style="color: #000040;">*</span> right<span style="color: #008080;">;</span>                            <span style="color: #0000ff;">public</span> Node Right<span style="color: #008080;">;</span>
    <span style="color: #0000ff;">int</span> data<span style="color: #008080;">;</span>                                    <span style="color: #0000ff;">public</span> <span style="color: #0000ff;">int</span> Data<span style="color: #008080;">;</span>
<span style="color: #008000;">&#125;</span>                                              <span style="color: #008000;">&#125;</span>
<span style="color: #666666;">//Сигнатура функции на C++</span>
<span style="color: #0000ff;">bool</span> isBalanced<span style="color: #008000;">&#40;</span>tree_node<span style="color: #000040;">*</span> root<span style="color: #008000;">&#41;</span> <span style="color: #008000;">&#123;</span> <span style="color: #666666;">//...</span></pre></div></div>

<p><a title="Обсуждение задачи" href="http://www.fulcrumweb.com.ua/?p=984">Посмотрите пост, связанный с этой задачей</a></p>
<p><div class='et-learn-more clearfix'>
					<h3 class='heading-more'><span>Подсказка идеи алгоритма</span></h3>
					<div class='learn-more-content'>Сбалансированное дерево определяется как такое дерево, что в нет двух листьев расстояние от корня до которых отличаются больше чем на 1. Иными словами, дерево будет сбалансированным, если длина максимального пути в нем отличается от длины минимального пути не более, чем на единицу. Для решения нужно, таким образом, найти длины этих двух путей и сравнить их.</p>
<pre>   //ТЕСТОВЫЕ ДАННЫЕ
   //Несбалансированное  дерево
   //                5
   //        3               7
   //    1      4       6       8
   //             10
   //           12  13
   //Сбалансированное  дерево
   //                5
   //        3               7
   //    1      4       6       8
   //             10
</pre></div>
				</div><br /> <div class='et-learn-more clearfix'>
					<h3 class='heading-more'><span>Код решения задачи на C++</span></h3>
					<div class='learn-more-content'>
<div class="wp_syntax"><table><tr><td class="line_numbers"><pre>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
</pre></td><td class="code"><pre class="cpp" style="font-family:monospace;"><span style="color: #339900;">#include &lt;algorithm&gt;</span>
<span style="color: #666666;">//----------------------------------------------------------------</span>
 <span style="color: #0000ff;">int</span> maxDepth<span style="color: #008000;">&#40;</span>tree_node<span style="color: #000040;">*</span> root<span style="color: #008000;">&#41;</span><span style="color: #008000;">&#123;</span>
   <span style="color: #0000ff;">if</span> <span style="color: #008000;">&#40;</span><span style="color: #000040;">!</span>root<span style="color: #008000;">&#41;</span> <span style="color: #008000;">&#123;</span>
     <span style="color: #0000ff;">return</span> <span style="color: #0000dd;">0</span><span style="color: #008080;">;</span>
   <span style="color: #008000;">&#125;</span>
   <span style="color: #0000ff;">return</span> <span style="color: #0000dd;">1</span> <span style="color: #000040;">+</span> max<span style="color: #008000;">&#40;</span>maxDepth<span style="color: #008000;">&#40;</span>root<span style="color: #000040;">-</span><span style="color: #000080;">&gt;</span>left<span style="color: #008000;">&#41;</span>, maxDepth<span style="color: #008000;">&#40;</span>root<span style="color: #000040;">-</span><span style="color: #000080;">&gt;</span>right<span style="color: #008000;">&#41;</span><span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span>
 <span style="color: #008000;">&#125;</span>
&nbsp;
 <span style="color: #0000ff;">int</span> minDepth<span style="color: #008000;">&#40;</span>tree_node<span style="color: #000040;">*</span> root<span style="color: #008000;">&#41;</span> <span style="color: #008000;">&#123;</span>
   <span style="color: #0000ff;">if</span> <span style="color: #008000;">&#40;</span><span style="color: #000040;">!</span>root<span style="color: #008000;">&#41;</span> <span style="color: #008000;">&#123;</span>
     <span style="color: #0000ff;">return</span> <span style="color: #0000dd;">0</span><span style="color: #008080;">;</span>
   <span style="color: #008000;">&#125;</span>
   <span style="color: #0000ff;">return</span> <span style="color: #0000dd;">1</span> <span style="color: #000040;">+</span> min<span style="color: #008000;">&#40;</span>minDepth<span style="color: #008000;">&#40;</span>root<span style="color: #000040;">-</span><span style="color: #000080;">&gt;</span>left<span style="color: #008000;">&#41;</span>, minDepth<span style="color: #008000;">&#40;</span>root<span style="color: #000040;">-</span><span style="color: #000080;">&gt;</span>right<span style="color: #008000;">&#41;</span><span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span>
 <span style="color: #008000;">&#125;</span>
&nbsp;
 <span style="color: #0000ff;">bool</span> isBalanced<span style="color: #008000;">&#40;</span>tree_node<span style="color: #000040;">*</span> root<span style="color: #008000;">&#41;</span><span style="color: #008000;">&#123;</span>
   <span style="color: #0000ff;">return</span> <span style="color: #008000;">&#40;</span>maxDepth<span style="color: #008000;">&#40;</span>root<span style="color: #008000;">&#41;</span> <span style="color: #000040;">-</span> minDepth<span style="color: #008000;">&#40;</span>root<span style="color: #008000;">&#41;</span> <span style="color: #000080;">&lt;=</span> <span style="color: #0000dd;">1</span><span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span>
 <span style="color: #008000;">&#125;</span></pre></td></tr></table></div>
</div>
				</div></p>
]]></content:encoded>
			<wfw:commentRss>http://www.fulcrumweb.com.ua/archives/2401/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Бинарное дерево минимальной высоты</title>
		<link>http://www.fulcrumweb.com.ua/archives/2399</link>
		<comments>http://www.fulcrumweb.com.ua/archives/2399#comments</comments>
		<pubDate>Tue, 17 Jan 2012 17:02:04 +0000</pubDate>
		<dc:creator>galina</dc:creator>
				<category><![CDATA[Деревья и графы]]></category>
		<category><![CDATA[Время до 30 мин]]></category>
		<category><![CDATA[Язык C#]]></category>
		<category><![CDATA[Язык C++]]></category>

		<guid isPermaLink="false">http://www.fulcrumweb.com.ua/?p=2399</guid>
		<description><![CDATA[Дан одномерный целочисленный массив. Нужно построить из его значений бинарное дерево поиска (BST) минимальной высоты. Желательно продемонстрировать использование стандартных STL контейнеров для C++. На C# постарайтесь не применять XML для описания структуры дерева. //Структура узла // C++ C# struct tree_node public class Node { { tree_node* left; public Node Left; tree_node* right; public Node Right; [...]]]></description>
			<content:encoded><![CDATA[<p>Дан одномерный целочисленный массив. Нужно построить из его значений бинарное дерево поиска (BST) минимальной высоты. Желательно продемонстрировать использование стандартных STL контейнеров для C++. На C# постарайтесь не применять XML для описания структуры дерева.</p>
<pre class="pre_code">
//Структура узла
//    C++                                           C#
struct tree_node                              public class Node
{                                             {
    tree_node* left;                             public Node Left;
    tree_node* right;                            public Node Right;
    int data;                                    public int Data;
}                                              }
</pre>
<p>Критерии оценки FulcrumWeb:</p>
<p><strong><img title="More..." src="http://fulcrumweb.com.ua/ukr/wp-includes/js/tinymce/plugins/wordpress/img/trans.gif" alt="" /></strong></p>
<p>Основываясь на знании стандартных приемов работы с бинарными деревьями и классических алгоритмов, необходимо придумать идею, на которой будет основано решение. </p>
<p>Оценка результатов:</p>
<p>Для начинающего программиста годится любая реализация, возможно содержащая ошибки, которые будут исправлены после указания на них.</p>
<p>В решении на <strong>C++</strong> обязательно не должно быть утечек памяти.</p>
<p>От более опытных кандидатов на <strong>C++</strong> требуется решение с использованием STL, в противном случае вопрос об STL будет поднят интервьюером.</p>
<div class='et-learn-more clearfix'>
					<h3 class='heading-more'><span>Ссылки на посты с намеками на идею алгоритма</span></h3>
					<div class='learn-more-content'><a title="Проверка сбалансированности B-дерева" href="http://www.fulcrumweb.com.ua/?p=2401"> Проверка сбалансированности B-дерева</a></p>
<p>
<a title="Бинарный поиск" href="http://www.fulcrumweb.com.ua/archives/1022#comment-88"> Бинарный поиска элемента в массиве</a></div>
				</div>
]]></content:encoded>
			<wfw:commentRss>http://www.fulcrumweb.com.ua/archives/2399/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Linux Embedded С++ Developer</title>
		<link>http://www.fulcrumweb.com.ua/archives/2335</link>
		<comments>http://www.fulcrumweb.com.ua/archives/2335#comments</comments>
		<pubDate>Tue, 03 Jan 2012 19:40:15 +0000</pubDate>
		<dc:creator>galina</dc:creator>
				<category><![CDATA[Вакансии]]></category>

		<guid isPermaLink="false">http://www.fulcrumweb.com.ua/?p=2335</guid>
		<description><![CDATA[The company «FulcrumWeb» invites to a permanent, well-paid job experienced Linux Embedded DeveloperPosition code: [Cpp_Linux]Number of vacancies: 1Closing period: January 2012 Requirements English: Sufficient to discuss all technical matters and to write specifications and documentation in English. Education: Bachelor or Master graduated preferable in Electronics. At least 2 years of work experience. Preferable: Experience in [...]]]></description>
			<content:encoded><![CDATA[<p>The company «FulcrumWeb» invites to a permanent, well-paid job experienced Linux Embedded Developer<br />Position code: <strong>[Cpp_Linux]</strong><br />Number of vacancies: <strong>1</strong><br />Closing period: January 2012</p>
<p><strong><underline>Requirements</strong></underline></p>
<p>English: Sufficient to discuss all technical matters and to write specifications and documentation in English.<br />
Education: Bachelor or Master graduated preferable in Electronics.<br />
At least 2 years of work experience.<br />
Preferable:</p>
<ul>
<li>Experience in embedded Systems. </li>
<li>Embedded LINUX.</li>
<li>Bootloader.</li>
<li>Flash-based Systems.</li>
<li>ARM processors.</li>
<li>LINUX real time extensions.</li>
<li>Profound C++ Knowledge. </li>
<li>Some experience in Assembler (preferable ARM). </li>
<li>Basic understanding of embedded hardware.</li>
</ul>
]]></content:encoded>
			<wfw:commentRss>http://www.fulcrumweb.com.ua/archives/2335/feed</wfw:commentRss>
		<slash:comments>2</slash:comments>
		</item>
		<item>
		<title>Создать список из вершин дерева: Решение</title>
		<link>http://www.fulcrumweb.com.ua/archives/2164</link>
		<comments>http://www.fulcrumweb.com.ua/archives/2164#comments</comments>
		<pubDate>Mon, 26 Dec 2011 11:29:02 +0000</pubDate>
		<dc:creator>galina</dc:creator>
				<category><![CDATA[Деревья и графы]]></category>
		<category><![CDATA[Связанные списки]]></category>
		<category><![CDATA[Приведено решение]]></category>
		<category><![CDATA[Пример кода]]></category>

		<guid isPermaLink="false">http://www.fulcrumweb.com.ua/?p=2164</guid>
		<description><![CDATA[В этом посте мы приводим два варианта решения задачи &#8220;Создать список из вершин дерева.&#8221; 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 [...]]]></description>
			<content:encoded><![CDATA[<p>В этом посте мы приводим <a title="Решение для этой задачи" href="http://www.fulcrumweb.com.ua/?p=991"> два варианта решения задачи &#8220;Создать список из вершин дерева.&#8221;</a></p>

<div class="wp_syntax"><table><tr><td class="line_numbers"><pre>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
</pre></td><td class="code"><pre class="cpp" style="font-family:monospace;"><span style="color: #339900;">#include &quot;stdafx.h&quot;</span>
<span style="color: #339900;">#include &lt;vector&gt;</span>
<span style="color: #339900;">#include </span>
&nbsp;
<span style="color: #0000ff;">using</span> <span style="color: #0000ff;">namespace</span> std<span style="color: #008080;">;</span>
<span style="color: #666666;">//Описание структуры узла</span>
  <span style="color: #0000ff;">struct</span> tree_node
        <span style="color: #008000;">&#123;</span>
           tree_node<span style="color: #000040;">*</span> left<span style="color: #008080;">;</span>
           tree_node<span style="color: #000040;">*</span> right<span style="color: #008080;">;</span>
           <span style="color: #0000ff;">int</span> data<span style="color: #008080;">;</span>
&nbsp;
           tree_node <span style="color: #008000;">&#40;</span><span style="color: #0000ff;">int</span> Data<span style="color: #008000;">&#41;</span> <span style="color: #008080;">:</span> left<span style="color: #008000;">&#40;</span><span style="color: #0000ff;">NULL</span><span style="color: #008000;">&#41;</span>, right<span style="color: #008000;">&#40;</span><span style="color: #0000ff;">NULL</span><span style="color: #008000;">&#41;</span>, data<span style="color: #008000;">&#40;</span>Data<span style="color: #008000;">&#41;</span><span style="color: #008000;">&#123;</span>
           <span style="color: #008000;">&#125;</span>
&nbsp;
           tree_node <span style="color: #008000;">&#40;</span><span style="color: #008000;">&#41;</span> <span style="color: #008080;">:</span> left<span style="color: #008000;">&#40;</span><span style="color: #0000ff;">NULL</span><span style="color: #008000;">&#41;</span>, right<span style="color: #008000;">&#40;</span><span style="color: #0000ff;">NULL</span><span style="color: #008000;">&#41;</span>, data<span style="color: #008000;">&#40;</span><span style="color: #0000dd;">0</span><span style="color: #008000;">&#41;</span><span style="color: #008000;">&#123;</span>
           <span style="color: #008000;">&#125;</span>
        <span style="color: #008000;">&#125;</span><span style="color: #008080;">;</span>
&nbsp;
  <span style="color: #666666;">//ПЕРВЫЙ ВАРИАНТ (без использования STL). Ответ на второй вопрос - ДА.</span>
  <span style="color: #666666;">//Результат - односвязный динамический список list_header.        </span>
&nbsp;
  <span style="color: #0000ff;">void</span> nodes_on_level<span style="color: #008000;">&#40;</span><span style="color: #0000ff;">const</span> tree_node<span style="color: #000040;">*</span> root, <span style="color: #0000ff;">int</span> <span style="color: #000040;">&amp;</span>curr_level, <span style="color: #0000ff;">int</span> level,
                tree_node<span style="color: #000040;">*</span> <span style="color: #000040;">&amp;</span>list_header, tree_node<span style="color: #000040;">*</span> <span style="color: #000040;">&amp;</span>cur_list_node<span style="color: #008000;">&#41;</span>
  <span style="color: #008000;">&#123;</span>
    <span style="color: #0000ff;">if</span><span style="color: #008000;">&#40;</span>root<span style="color: #008000;">&#41;</span>
    <span style="color: #008000;">&#123;</span>
      <span style="color: #0000ff;">if</span> <span style="color: #008000;">&#40;</span>curr_level <span style="color: #000080;">==</span> level<span style="color: #008000;">&#41;</span>
      <span style="color: #008000;">&#123;</span>
        tree_node<span style="color: #000040;">*</span> new_list_node <span style="color: #000080;">=</span> <span style="color: #0000dd;">new</span> tree_node<span style="color: #008000;">&#40;</span>root<span style="color: #000040;">-</span><span style="color: #000080;">&gt;</span>data<span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span>
&nbsp;
        <span style="color: #0000ff;">if</span> <span style="color: #008000;">&#40;</span>list_header<span style="color: #008000;">&#41;</span>
          cur_list_node<span style="color: #000040;">-</span><span style="color: #000080;">&gt;</span>left <span style="color: #000080;">=</span> new_list_node<span style="color: #008080;">;</span>
        <span style="color: #0000ff;">else</span>
          list_header <span style="color: #000080;">=</span> new_list_node<span style="color: #008080;">;</span>
&nbsp;
        cur_list_node <span style="color: #000080;">=</span> new_list_node<span style="color: #008080;">;</span>
      <span style="color: #008000;">&#125;</span>
      curr_level<span style="color: #000040;">++</span><span style="color: #008080;">;</span>
      <span style="color: #0000ff;">if</span><span style="color: #008000;">&#40;</span>root<span style="color: #000040;">-</span><span style="color: #000080;">&gt;</span>left <span style="color: #000040;">&amp;&amp;</span> curr_level left,curr_level,level,list_header,cur_list_node<span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span>
      <span style="color: #008000;">&#125;</span>
      <span style="color: #0000ff;">if</span><span style="color: #008000;">&#40;</span>root<span style="color: #000040;">-</span><span style="color: #000080;">&gt;</span>right <span style="color: #000040;">&amp;&amp;</span> curr_level right, curr_level,level,list_header,cur_list_node<span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span>
      <span style="color: #008000;">&#125;</span>
      curr_level<span style="color: #000040;">--</span><span style="color: #008080;">;</span>
    <span style="color: #008000;">&#125;</span>
  <span style="color: #008000;">&#125;</span>
&nbsp;
<span style="color: #666666;">//Метод для очистки памяти, динамически выделенной под линейный список - ОБЯЗАТЕЛЕН!</span>
   <span style="color: #0000ff;">void</span> remove_linked_list<span style="color: #008000;">&#40;</span>tree_node<span style="color: #000040;">*</span> <span style="color: #000040;">&amp;</span>list_header<span style="color: #008000;">&#41;</span>
   <span style="color: #008000;">&#123;</span>
     tree_node<span style="color: #000040;">*</span> deleted_node<span style="color: #008080;">;</span>
     <span style="color: #0000ff;">do</span>
     <span style="color: #008000;">&#123;</span>
       <span style="color: #0000dd;">cout</span> <span style="color: #000080;">&lt;&lt;</span> list_header<span style="color: #000040;">-</span><span style="color: #000080;">&gt;</span>data<span style="color: #000080;">&lt;&lt;</span> endl<span style="color: #008080;">;</span> <span style="color: #666666;">//Для проверки, что удаление прошло</span>
       deleted_node <span style="color: #000080;">=</span> list_header<span style="color: #008080;">;</span>
       list_header <span style="color: #000080;">=</span> list_header<span style="color: #000040;">-</span><span style="color: #000080;">&gt;</span>left<span style="color: #008080;">;</span>
       <span style="color: #0000dd;">delete</span> deleted_node<span style="color: #008080;">;</span>
     <span style="color: #008000;">&#125;</span>
     <span style="color: #0000ff;">while</span> <span style="color: #008000;">&#40;</span>list_header<span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span>
   <span style="color: #008000;">&#125;</span>
<span style="color: #ff0000; font-style: italic;">/*--------------------------------------------------------------------------------------*/</span>
&nbsp;
  <span style="color: #666666;">//ВТОРОЙ ВАРИАНТ (с использованием STL).</span>
  <span style="color: #666666;">//Результат - вектор vector</span>
<span style="color: #000080;">&lt;</span>tree_node<span style="color: #000080;">&gt;</span><span style="color: #000040;">&amp;</span> nodes_list.   
&nbsp;
<span style="color: #0000ff;">void</span> nodes_on_level_stl<span style="color: #008000;">&#40;</span><span style="color: #0000ff;">const</span> tree_node<span style="color: #000040;">*</span> root,  <span style="color: #0000ff;">int</span><span style="color: #000040;">&amp;</span> curr_level, <span style="color: #0000ff;">int</span> level,
                        vector<span style="color: #000040;">&amp;</span> nodes_list, tree_node<span style="color: #000040;">&amp;</span> curr_list_node<span style="color: #008000;">&#41;</span>
<span style="color: #008000;">&#123;</span>
  <span style="color: #0000ff;">if</span><span style="color: #008000;">&#40;</span>root<span style="color: #008000;">&#41;</span>
  <span style="color: #008000;">&#123;</span>
    tree_node cur_list_node<span style="color: #008000;">&#40;</span>root<span style="color: #000040;">-</span><span style="color: #000080;">&gt;</span>data<span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span>
    <span style="color: #0000ff;">if</span> <span style="color: #008000;">&#40;</span>curr_level <span style="color: #000080;">==</span> level<span style="color: #008000;">&#41;</span>
    <span style="color: #008000;">&#123;</span>
      nodes_list.<span style="color: #007788;">push_back</span><span style="color: #008000;">&#40;</span>cur_list_node<span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span>
    <span style="color: #008000;">&#125;</span>
    curr_level<span style="color: #000040;">++</span><span style="color: #008080;">;</span>
    <span style="color: #0000ff;">if</span> <span style="color: #008000;">&#40;</span>curr_level left<span style="color: #008000;">&#41;</span>
      <span style="color: #008000;">&#123;</span>
        nodes_on_level_stl<span style="color: #008000;">&#40;</span>root<span style="color: #000040;">-</span><span style="color: #000080;">&gt;</span>left,curr_level,level, nodes_list, cur_list_node<span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span>
      <span style="color: #008000;">&#125;</span>
      <span style="color: #0000ff;">if</span><span style="color: #008000;">&#40;</span>root<span style="color: #000040;">-</span><span style="color: #000080;">&gt;</span>right<span style="color: #008000;">&#41;</span>
      <span style="color: #008000;">&#123;</span>
        nodes_on_level_stl<span style="color: #008000;">&#40;</span>root<span style="color: #000040;">-</span><span style="color: #000080;">&gt;</span>right, curr_level,level,nodes_list,cur_list_node<span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span>
      <span style="color: #008000;">&#125;</span>
    <span style="color: #008000;">&#125;</span>
    curr_level<span style="color: #000040;">--</span><span style="color: #008080;">;</span>
  <span style="color: #008000;">&#125;</span>
<span style="color: #008000;">&#125;</span><span style="color: #008080;">;</span>
&nbsp;
<span style="color: #666666;">//Обертка вокруг основного метода реализована для сокрытия вспомогательных параметров,</span>
<span style="color: #666666;">//нужных для организации рекурсии. Это полезно сделать и для первого варианта.</span>
&nbsp;
std<span style="color: #008080;">::</span><span style="color: #007788;">vector</span>
 nodes_on_level_stl_CALL<span style="color: #008000;">&#40;</span><span style="color: #0000ff;">const</span> tree_node<span style="color: #000040;">*</span> root, <span style="color: #0000ff;">int</span> level<span style="color: #008000;">&#41;</span>
<span style="color: #008000;">&#123;</span>
  vector
 nodes_list<span style="color: #008080;">;</span><span style="color: #666666;">//вместо списка tree_node* &amp;list_header</span>
  <span style="color: #0000ff;">int</span> cur_level <span style="color: #000080;">=</span> <span style="color: #0000dd;">0</span><span style="color: #008080;">;</span>
  tree_node level_nodes_<span style="color: #008080;">;</span>
  nodes_on_level_stl<span style="color: #008000;">&#40;</span>root, cur_level, level,nodes_list, level_nodes_<span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span>
  <span style="color: #0000ff;">return</span> nodes_list<span style="color: #008080;">;</span>
<span style="color: #008000;">&#125;</span>
&nbsp;
<span style="color: #ff0000; font-style: italic;">/*--------------------------------------------------------------------------------------*/</span>
<span style="color: #0000ff;">int</span> main<span style="color: #008000;">&#40;</span><span style="color: #008000;">&#41;</span>
<span style="color: #008000;">&#123;</span>
  <span style="color: #666666;">//ТЕСТОВЫЕ ДАННЫЕ</span>
  <span style="color: #666666;">//Бинарное дерево заданно</span>
  <span style="color: #666666;">//                5</span>
  <span style="color: #666666;">//        3               7</span>
  <span style="color: #666666;">//    1      4       6       8</span>
  <span style="color: #666666;">//             10</span>
  <span style="color: #666666;">//           12  13</span>
  <span style="color: #666666;">//Для номера уровня 2 результат 1 -&gt; 4 -&gt; 6 -&gt; 8</span>
&nbsp;
tree_node Node0<span style="color: #008000;">&#40;</span><span style="color: #0000dd;">5</span><span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span>
tree_node Node1<span style="color: #008000;">&#40;</span><span style="color: #0000dd;">3</span><span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span> tree_node Node2<span style="color: #008000;">&#40;</span><span style="color: #0000dd;">7</span><span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span>
tree_node Node3<span style="color: #008000;">&#40;</span><span style="color: #0000dd;">1</span><span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span> tree_node Node4<span style="color: #008000;">&#40;</span><span style="color: #0000dd;">4</span><span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span> tree_node Node5<span style="color: #008000;">&#40;</span><span style="color: #0000dd;">6</span><span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span> tree_node Node6<span style="color: #008000;">&#40;</span><span style="color: #0000dd;">8</span><span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span>
tree_node Node7<span style="color: #008000;">&#40;</span><span style="color: #0000dd;">10</span><span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span>
tree_node Node8<span style="color: #008000;">&#40;</span><span style="color: #0000dd;">12</span><span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span> tree_node Node9<span style="color: #008000;">&#40;</span><span style="color: #0000dd;">13</span><span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span>
&nbsp;
      Node0.<span style="color: #007788;">left</span> <span style="color: #000080;">=</span> <span style="color: #000040;">&amp;</span>Node1<span style="color: #008080;">;</span>
      Node0.<span style="color: #007788;">right</span> <span style="color: #000080;">=</span> <span style="color: #000040;">&amp;</span>Node2<span style="color: #008080;">;</span>
      Node1.<span style="color: #007788;">left</span> <span style="color: #000080;">=</span> <span style="color: #000040;">&amp;</span>Node3<span style="color: #008080;">;</span>
      Node1.<span style="color: #007788;">right</span> <span style="color: #000080;">=</span> <span style="color: #000040;">&amp;</span>Node4<span style="color: #008080;">;</span>
      Node2.<span style="color: #007788;">left</span> <span style="color: #000080;">=</span> <span style="color: #000040;">&amp;</span>Node5<span style="color: #008080;">;</span>
      Node2.<span style="color: #007788;">right</span> <span style="color: #000080;">=</span> <span style="color: #000040;">&amp;</span>Node6<span style="color: #008080;">;</span>
      Node4.<span style="color: #007788;">right</span> <span style="color: #000080;">=</span> <span style="color: #000040;">&amp;</span>Node7<span style="color: #008080;">;</span>
      Node7.<span style="color: #007788;">left</span> <span style="color: #000080;">=</span> <span style="color: #000040;">&amp;</span>Node8<span style="color: #008080;">;</span>
      Node7.<span style="color: #007788;">right</span> <span style="color: #000080;">=</span> <span style="color: #000040;">&amp;</span>Node9<span style="color: #008080;">;</span>
<span style="color: #ff0000; font-style: italic;">/*------------------------------------------------------------------*/</span>
&nbsp;
<span style="color: #666666;">//Вызов для варианта с использованием STL</span>
  vector
 nodes_list <span style="color: #000080;">=</span> nodes_on_level_stl_CALL<span style="color: #008000;">&#40;</span><span style="color: #000040;">&amp;</span>Node0, <span style="color: #0000dd;">2</span><span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span>
&nbsp;
<span style="color: #ff0000; font-style: italic;">/*------------------------------------------------------------------*/</span>
<span style="color: #666666;">//Вызов для варианта с без STL</span>
 tree_node<span style="color: #000040;">*</span> list_header <span style="color: #000080;">=</span> <span style="color: #0000ff;">NULL</span><span style="color: #008080;">;</span>
 tree_node<span style="color: #000040;">*</span> cur_list_node <span style="color: #000080;">=</span> <span style="color: #0000ff;">NULL</span><span style="color: #008080;">;</span>
 <span style="color: #0000ff;">int</span> cur_level <span style="color: #000080;">=</span> <span style="color: #0000dd;">0</span><span style="color: #008080;">;</span>
 nodes_on_level<span style="color: #008000;">&#40;</span><span style="color: #000040;">&amp;</span>Node0, cur_level, <span style="color: #0000dd;">2</span>, list_header, cur_list_node<span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span>
<span style="color: #666666;">//Очистить память, выделенную в куче для создания списка узлов</span>
  remove_linked_list<span style="color: #008000;">&#40;</span>list_header<span style="color: #008000;">&#41;</span><span style="color: #008080;">;</span>
<span style="color: #008000;">&#125;</span></pre></td></tr></table></div>

]]></content:encoded>
			<wfw:commentRss>http://www.fulcrumweb.com.ua/archives/2164/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Копирование битов: Решение</title>
		<link>http://www.fulcrumweb.com.ua/archives/2049</link>
		<comments>http://www.fulcrumweb.com.ua/archives/2049#comments</comments>
		<pubDate>Thu, 22 Dec 2011 13:26:34 +0000</pubDate>
		<dc:creator>galina</dc:creator>
				<category><![CDATA[Манипуляция битами]]></category>

		<guid isPermaLink="false">http://www.fulcrumweb.com.ua/?p=2049</guid>
		<description><![CDATA[Ниже приведен код, который, по нашему мнению, является приемлемым решением задачи &#8220;Копирование битов&#8221; Из кода видно условие проверки корректности значений startBit и stopBit (первый вопрос). Приведенные тестовые вызовы функции дают ответ на второй вопрос, уточняя на примерах ее поведение. int copy_bits( int A, int B, int startBit, int stopBit) //Post 999 { /* Биты считаем [...]]]></description>
			<content:encoded><![CDATA[<p>Ниже приведен код, который, по нашему мнению, является приемлемым <a title="Решение для этой задачи" href="http://www.fulcrumweb.com.ua/?p=999"> решением задачи &#8220;Копирование битов&#8221;</a></p>
<p>Из кода видно условие проверки корректности значений startBit и stopBit (первый вопрос). Приведенные тестовые вызовы функции дают ответ на второй вопрос, уточняя на примерах ее поведение.</p>
<p>
<code><br />
int copy_bits( int A, int B, int startBit, int stopBit) //Post 999<br />
{</p>
<p>  /* Биты считаем с нулевого, нулевой - это самый младший бит числа */</p>
<p>  if((startBit > stopBit) || !(stopBit >= 0 &#038;&#038; stopBit <=31)<br />
        || !(startBit >= 0 &#038;&#038; startBit <=31))<br />
  {<br />
    cout << "Incorrect stopBit||startBit";<br />
    return A;<br />
  }</p>
<p>  int max = ~0; /* All 1’s, so max = 0xFFFFFFFF */</p>
<p>  // 1’s through position stopBit, then 0’s<br />
  int left = max - ((1 << stopBit) - 1);</p>
<p>  // 1’s after position startBit<br />
  int right = ((1 << startBit) - 1);</p>
<p>  //Mask: 1’s, with 0s between startBit and stopBit<br />
  int mask = left | right;</p>
<p>  // Clear startBit through stopBit in A<br />
  A = A & mask; </p>
<p>  //Clear all bits in B except bits between startBit and stopBit<br />
  B = B &#038; ~mask;</p>
<p>  // put bits from B there<br />
  return A | B;<br />
}</p>
<p>int main()<br />
{/* Unit tests for POST "Копирование битов" */</p>
<p>/* A: 1111 0101 (245) B: 0000 0100 (4) result should be: 1110 0101 (229) */<br />
  int n1 = copy_bits(245,4,2,5);<br />
/* A: 1111 0101 (245) B: 0000 0100 (4) result should be: 1100 0101 (197) */<br />
  int n2 = copy_bits(245,4,2,6);<br />
/* A: 1111 0101 (245) B: 0000 0101 (5) result should be: 1100 0101 (229) */<br />
  int n3 = copy_bits(245,5,2,5);<br />
/* A: 0111 0101 (117) B: 1000 0101 (133) result should be: 0110 0101 (101)*/<br />
  int n6 = copy_bits(117,133,2,5);<br />
}<br />
</code></p>
]]></content:encoded>
			<wfw:commentRss>http://www.fulcrumweb.com.ua/archives/2049/feed</wfw:commentRss>
		<slash:comments>8</slash:comments>
		</item>
		<item>
		<title>Марафон вопросов и ответов C++</title>
		<link>http://www.fulcrumweb.com.ua/archives/2000</link>
		<comments>http://www.fulcrumweb.com.ua/archives/2000#comments</comments>
		<pubDate>Tue, 13 Dec 2011 13:46:37 +0000</pubDate>
		<dc:creator>Jacob</dc:creator>
				<category><![CDATA[Языки программирования]]></category>
		<category><![CDATA[C++]]></category>
		<category><![CDATA[Опытный программист]]></category>
		<category><![CDATA[Язык C++]]></category>

		<guid isPermaLink="false">http://www.fulcrumweb.com.ua/?p=2000</guid>
		<description><![CDATA[Специально для опытных программистов предлагается “марафон” вопросов и ответов. Рекомендуется пробежать перед прохождением собеседования. Источник этого списка – форумы сайта RSDN. 1. Что определяет класс? Чем обличается класс от объекта? Класс определяет пользовательский тип: описание данных и операций над ними. Объект &#8211; это конкретный экземпляр класса со своим состоянием. 2. Можно ли объявлять массив объектов? [...]]]></description>
			<content:encoded><![CDATA[<p>Специально для <strong>опытных программистов</strong> предлагается “марафон” вопросов и ответов. Рекомендуется пробежать перед прохождением собеседования.</p>
<p>Источник этого списка – форумы сайта RSDN.</p>
<p><strong> </strong></p>
<p><strong>1. Что определяет класс? Чем обличается класс от объекта?</strong></p>
<p>Класс определяет пользовательский тип: описание данных и операций над ними. Объект &#8211; это конкретный экземпляр класса со своим состоянием.</p>
<p><strong>2. Можно ли объявлять массив объектов? А массив классов?</strong></p>
<p>Да. Нет. Только в метапрограммировании. boost::tuple</p>
<p> <span id="more-2000"></span></p>
<p><strong>3. Разрешается ли объявлять указатель на объект? А указатель на класс?</strong></p>
<p>Да. Нет.</p>
<p><strong>4. Допускается ли передавать объекты в качестве параметров, и какими способами? А возвращать как результат?</strong></p>
<p>По ссылке, по указателю. Возвращать также. По значению передаётся копия объекта.</p>
<p><strong>5. Как называется использование объекта одного класса в качестве поля другого класса?</strong></p>
<p>Композиция.</p>
<p><strong>6. Является ли структура классом? Чем класс отличается от структуры?</strong></p>
<p>Да. По умолчанию в классе все поля private</p>
<p><strong>7. Какие ключевые слова в С++ обозначают класс?</strong></p>
<p>class, struct</p>
<p><strong>8. Объясните принцип инкапсуляции.</strong></p>
<p>Сокрытие деталей реализации.</p>
<p><strong>9. Что такое композиция?</strong></p>
<p>Использование объекта одного класса в качестве поля другого.</p>
<p><strong>10. Для чего используются ключевые слова public и private?</strong></p>
<p>Для определения области видимости.</p>
<p><strong>11. Можно ли использовать ключевые слова public и private в структуре?</strong></p>
<p>Да.</p>
<p><strong>12. Существуют ли ограничения на использование public и private в классе? А в структуре?</strong></p>
<p>Нет. Нет.</p>
<p><strong>13. Обязательно ли делать поля класса приватными?</strong></p>
<p>Нет.</p>
<p><strong>14. Что такое метод? Как вызывается метод?</strong></p>
<p>Метод &#8211; это функция, определённая в классе.</p>
<p>Если статический, то вызывается для класса, если обычный &#8211; то для объекта класса.</p>
<p><strong>15. Может ли метод быть приватный?</strong></p>
<p>Да.</p>
<p><strong>16. Как определить метод непосредственно внутри класса? А вне класса? Чем эти определения отличаются?</strong></p>
<p>class A</p>
<p>{</p>
<p>        void method x{}</p>
<p>};</p>
<p><strong>17. Можно в методах присваивать параметрам значения по умолчанию?</strong></p>
<p>Да. Существуют дополнительные ограничения.</p>
<p><strong>18. Что обозначается ключевым словом this?</strong></p>
<p>Указатель на объект, который вызвал метод.</p>
<p><strong>19. Зачем нужны константные методы? Чем отличается определение константного метода от обычного?</strong></p>
<p>Чтобы предотвратить случайное изменение данных внутри метода и показать, что метод не меняет состояние класса.</p>
<p><strong>20. Может ли константный метод вызываться для объектов-переменных? А обычный метод — для объектов-констант?</strong></p>
<p>Да. Нет.</p>
<p><strong>21. Объясните принцип полиморфизма.</strong></p>
<p>Возможность работать с объектами разных классов одинаковым образом.</p>
<p>Поддержка различного поведения родственных классов, предоставляемого через единый интерфейс базового класса.</p>
<p>Есть статический &#8211; на этапе компиляции. Шаблоны, перегрузка функций и операторов.</p>
<p>Есть динамический &#8211; виртуальные функции. Точное значение операции определяется объектом для которого она вызывается.</p>
<p><strong>22. Сколько места в памяти занимает объект класса? Как это узнать?</strong></p>
<p>Столько, сколько все его поля, кроме статических, плюс размер указателя &#8211; информация о типе (1 char на gcc 32 bit).</p>
<p><strong>23. Каков размер «пустого» объекта?</strong></p>
<p>В типичной реализации &#8211; размер указателя. Это информация о типе.</p>
<p><strong>24. Влияют ли методы на размер объекта?</strong></p>
<p>Нет.</p>
<p><strong>25. Одинаков ли размер класса и аналогичной структуры?</strong></p>
<p>Да.</p>
<p><strong>26. Какие операции нельзя перегружать? Как вы думаете, почему?</strong></p>
<p>sizeof, ., .*, typeid ?:</p>
<p>потому что их операнд &#8211; это имя типа.</p>
<p><strong>27. Можно ли перегружать операции для встроенных типов данных?</strong></p>
<p>Нет, потому что тип &#8211; это набор данных и операций над ними. Изменяя семантику типа, мы меняем само определение типа.</p>
<p><strong>28. Можно ли при перегрузке изменить приоритет операции?</strong></p>
<p>Нет.</p>
<p><strong>29. Можно ли определить новую операцию?</strong></p>
<p>Нет. Надо пользоваться функциями.</p>
<p><strong>30. Перечислите особенности перегрузки операций как методов класса. Чем отличается перегрузка внешним образом от перегрузки как метода класса?</strong></p>
<p>На один параметр меньше, чем внешняя перегрузка.</p>
<p><strong>31. Какой результат должны возвращать операции с присваиванием?</strong></p>
<p>Ссылку.</p>
<p><strong>32. Как различаются перегруженная префиксная и постфиксная операции инкремента и декремента?</strong></p>
<p>Постфикс имеет фиктивный параметр.</p>
<p><strong>33. Что означает выражение *this? В каких случаях оно используется?</strong></p>
<p>Ссылка на объект.</p>
<p>Для разрешения неоднозначности, для определения размера.</p>
<p><strong>34. Какие операции не рекомендуется перегружать как методы класса? Почему?</strong></p>
<p>Те, которым не нужен доступ к внутренним переменным класса. Чтобы не нарушать инкапсуляции.</p>
<p><strong>35. Какие операции разрешается перегружать только как методы класса?</strong></p>
<p>Те, для которых нужна гарантия, что их первый операнд lvalue.</p>
<p>= [] -></p>
<p><strong>36. Дайте определение дружественной функции. Как объявляется дружественная функция? А как определяется?</strong></p>
<p>Функция имеет доступ к закрытой части класса.</p>
<p>Не находится в области видимости класса.</p>
<p>Не должна вызываться для объекта класса.</p>
<p><strong>37. Дайте определение конструктора. Каково назначение конструктора? </strong>Перечислите отличия конструктора от метода.</p>
<p>Специальный метод для инициализации объекта.</p>
<p>Не имеет возвращаемого значения. Не может быть статическим, виртуальным. Внутри не работает механизм виртуальных функций, потому что ещё не инициализирована таблица виртуальных функций.</p>
<p><strong>38. Сколько конструкторов может быть в классе? Допускается ли перегрузка конструкторов? Какие виды конструкторов создаются по умолчанию?</strong></p>
<p>Сколько угодно. Да. default ctor, copy ctor.</p>
<p><strong>39. Может ли конструктор быть приватным? Какие последствия влечет за собой объявление конструктора приватным?</strong></p>
<p>Да. Невозможность конструирования объекта класса.</p>
<p><strong>40. Приведите несколько случаев, когда конструктор вызывается неявно.</strong></p>
<p>Копирование, конструирование внутренних объектов, передача по значению, приведение типа.</p>
<p><strong>41. Как проинициализировать динамическую переменную?</strong></p>
<p>в списке инициализаторов</p>
<p>new</p>
<p>placement new</p>
<p>new(nothrow)</p>
<p><strong>42. Как объявить константу в классе? Можно ли объявить дробную константу?</strong></p>
<p>const int x; const double x;</p>
<p><strong>43. Каким образом разрешается инициализировать константные поля в классе?</strong></p>
<p>статические интегральные прямо на месте, остальные в инициализаторе или вне класса, или в конструкторе</p>
<p><strong>44. В каком порядке инициализируются поля в классе? Совпадает ли этот порядок с порядком перечисления инициализаторов в списке инициализации конструктора?</strong></p>
<p>В порядке объявления. Нет.</p>
<p><strong>45. Какие конструкции С++ разрешается использовать в списке инициализации качестве инициализирующих выражений?</strong></p>
<p>rvalue, инициализированные lvalue</p>
<p><strong>46. Какой вид конструктора фактически является конструктором преобразования типов?</strong></p>
<p>Конструктор не explicit</p>
<p><strong>47. Для чего нужны функции преобразования? Как объявить такую функцию в классе?</strong></p>
<p>Для корректного приведения неродственных типов между собой.</p>
<p>Как операторы преобразования.</p>
<p>        static_cast &#8211; иерархическое преобразование с проверкой на этапе компиляции</p>
<p>        reinterpret_cast &#8211; несвязанное преобразование с проверкой на этапе компиляции</p>
<p>        dynamic_cast &#8211; проверяется на этапе выполнения RTTI.</p>
<p>        const_cast &#8211; аннулирует const и volatile</p>
<p>operator int() const {return v;}</p>
<p><strong>48. Как запретить неявное преобразование типа, выполняемое конструктором инициализации?</strong></p>
<p>explicit</p>
<p><strong>49. Какие проблемы могут возникнуть при определении функций преобразования?</strong></p>
<p>Если определены операторы и преобразования, то может возникнуть конфликт между неявным преобразованием и пользовательскими операторами.</p>
<p><strong>50. Для чего служит ключевое слово explicit?</strong></p>
<p>Это модификатор для запрещения неявного преобразования типов объектов аргументов конструктора.</p>
<p><strong>51. Влияет ли наличие целочисленных констант-полей на размер класса?</strong></p>
<p>Если не static, то да.</p>
<p><strong>52. Разрешается ли объявлять массив в качестве поля класса. Как присвоить элементам массива начальные значения?</strong></p>
<p>Да. В классе &#8211; только в конструкторе. Если статический константый, то вне пределов класса.</p>
<p><strong>53. Сколько операндов имеет операция индексирования []? Какой вид результата должна возвращать эта операция?</strong></p>
<p>Один. Любой. Чаще лучше ссылку.</p>
<p><strong>54. Для чего нужны статические поля в классе? Как они определяются?</strong></p>
<p>Для хранения состояния класса. static int i;</p>
<p><strong>55. Как объявить в классе и проинициализировать статический константный массив?</strong></p>
<p>class A { static const int I[3]; } A::I[3] = {1, 2};</p>
<p><strong>56. Что такое выравнивание и от чего оно зависит? Влияет ли выравнивание на размер класса?</strong></p>
<p>Расположение данных в памяти поблочно, так как процессор читает машинными словами. Зависит от реализации компилятора, ОЗУ и процессора. Влияет.</p>
<p><strong>57. Дайте определение контейнера.</strong></p>
<p>Контейнер &#8211; это объект, хранящий другие объекты.</p>
<p><strong>58. Какие виды встроенных контейнеров в С++ вы знаете? На основе чего они реализованы</strong></p>
<p>Фундаментальные последовательности</p>
<p>        vector</p>
<p>        list</p>
<p>        deque</p>
<p>Адаптеры</p>
<p>        stack &#8211; вектор</p>
<p>        queue &#8211; дек</p>
<p>        priority_queue &#8211; куча</p>
<p>Ассоциативные контейнеры и множества</p>
<p>        map &#8211; деревья</p>
<p>        multimap</p>
<p>        set</p>
<p>        multiset</p>
<p>Почти контейнеры</p>
<p>        string</p>
<p>        valarray</p>
<p>        bitset</p>
<p>        vector<bool></p>
<p><strong>59. Какие виды доступа к элементам контейнера вам известны?</strong></p>
<p>Разыменовывание итератора и оператор индексирования, также специальные функции.</p>
<p><strong>60. Чем отличается прямой доступ от ассоциативного?</strong></p>
<p>Индексацией: целыми числами или значениями.</p>
<p><strong>61. Перечислите операции, которые обычно реализуются для последовательного доступа к элементам контейнера.</strong></p>
<p>begin(), end(), инкремент итератора, разыменование.</p>
<p><strong>62. Дайте определение итератора.</strong></p>
<p>Итератор это абстрактная модель данных, как последовательности объектов. Объект, который ведёт себя, как итератор &#8211; есть итератор. Ключевые концепции: инкремент, равенство и разыменование.</p>
<p><strong>63. Можно ли реализовать последовательный доступ без итератора? В чем преимущества реализации последовательного доступа с помощью итератора?</strong></p>
<p>Да. Единообразная работа с различными сущностями.</p>
<p><strong>64. Что играет роль итератора для массивов С++?</strong></p>
<p>Имя массива &#8211; указатель на начало и арифметика указателей.</p>
<p><strong>65. Что такое деструктор? Может ли деструктор иметь параметры?</strong></p>
<p>Специальная функция, отвечающая за уничтожение объекта. Нет.</p>
<p><strong>66. Почему для классов-контейнеров деструктор надо писать явным образом?</strong></p>
<p>Потому что управление переменной длиной конейнера требует динамического выделения памяти, которую, соответственно, надо уничтожать.</p>
<p><strong>67. Допускается ли перегрузка деструкторов?</strong></p>
<p>Нет, потому что он не имеет параметров.</p>
<p><strong>68. Что такое «глубокое копирование» и когда в нем возникает необходимость?</strong></p>
<p>Копирование значений полей класса, даже если они заданы указателями. При сериализации.</p>
<p><strong>69. Какое копирование осуществляет стандартный конструктор копирования?</strong></p>
<p>Вызывает конструкторы копирования баз и членов. Неглубокое копирование, если по умолчанию.</p>
<p><strong>70. Чем отличается копирование от присваивания?</strong></p>
<p>Это разные операции</p>
<p>Копирование &#8211; работает конструктор копирования, создаётся новый объект.</p>
<p>Присваивание &#8211; поля одного объекта заполняются значениями другого. Нового объекта не создаётся.</p>
<p><strong>71. Объясните, почему в операции присваивания требуется проверка присваивания самому себе?</strong></p>
<p>Не требуется, но рекомендуется. Для больших объектов весьма существенный выигрыш по времени.</p>
<p><strong>72. Можно ли в качестве операции индексирования использовать операцию вызова функции ()? В чем ее преимущества перед операцией []?</strong></p>
<p>Можно сделать это макросами. Можно сделать перегрузку оператора ()</p>
<p>Вызов с несколькими аргументами.</p>
<p><strong>73. Почему необходимо писать два определения операции индексирования? Чем они отличаются?</strong></p>
<p>Модификатором const. Нужно, чтобы была возможность изменять содержимое неконстантного контейнера и иметь доступ к константному.</p>
<p><strong>74. Дайте определение вложенного класса.</strong></p>
<p>Область видимости ограничена классом, в котором он объявлен.</p>
<p><strong>75. Можно ли класс-итератор реализовать как внешний класс? А как вложенный? В чем отличия этих методов реализации?</strong></p>
<p>Да. Да.</p>
<p>Во втором случае объект знает о типе итератора заранее.</p>
<p><strong>76. Может ли объемлющий класс иметь неограниченный доступ к элементам вложенного класса? А вложенный класс — к элементам объемлющего?</strong></p>
<p>Нет. Да.</p>
<p><strong>77. Ограничена ли глубина вложенности классов?</strong></p>
<p>Нет.</p>
<p><strong>78. Можно ли определить вложенный класс внешним образом? Зачем это может понадобиться?</strong></p>
<p>Да. Если вложенный класс нуждается в определении класса, в который он вложен. Или при раздельной трансляции.</p>
<p><strong>79. Каким образом вложенный класс может использовать методы объемлющего класса? А объемлющий — методы вложенного?</strong></p>
<p>Просто, вызывая их, если public.</p>
<p>Или сделав дружественный класс.</p>
<p><strong>80. Что такое «запредельный» элемент, какую роль он играет в контейнерах?</strong></p>
<p>Элемент, следующий за последним. Условие окончания перебора элементов.</p>
<p><strong>81. Объясните, по каким причинам трудно написать универсальный контейнер, элементы которого могут иметь произвольный тип.</strong></p>
<p>Из-за строгой типизации.</p>
<p><strong>82. Назовите ключевые слова С++, которые используются для обработки исключений.</strong></p>
<p>try, catch, throw</p>
<p><strong>83. Исключение — это:</strong></p>
<p><strong>1) событие;</strong></p>
<p><strong>2) ситуация;</strong></p>
<p><strong>3) объект;</strong></p>
<p><strong>4) ошибка в программе;</strong></p>
<p><strong>5) прерывание;</strong></p>
<p>        событие и объект, смотря с какой точки зрения.</p>
<p><strong>84. Каким образом исключение генерируется?</strong></p>
<p>Раскрутка стека. Поиск секции-обработчика.</p>
<p><strong>85. Каковы функции контролируемого блока?</strong></p>
<p>Отловить исключение, сгенерированное внутри него.</p>
<p><strong>86. Что обозначается ключевым словом catch?</strong></p>
<p>1) контролируемый блок;</p>
<p>2) блок обработки исключения;</p>
<p>3) секция-ловушка;</p>
<p>4) генератор исключения;</p>
<p>5) обработчик прерывания;</p>
<p>        2,3,5</p>
<p><strong>87. Какого типа может быть исключение?</strong></p>
<p>Любого. Это класс.</p>
<p><strong>88. Сколько параметров разрешается писать в заголовке секции-ловушки?</strong></p>
<p>Один.</p>
<p><strong>89. Какими способами разрешается передавать исключение в блок обработки?</strong></p>
<p>По значению, по ссылке или по указателю.</p>
<p><strong>90. Объясните, каким образом преодолеть ограничение на передачу единственного параметра в блок обработки.</strong></p>
<p>Завести класс, структуру или использовать несколько блоков обработки.</p>
<p><strong>91. Почему нельзя выполнять преобразования типов исключений при передаче в секцию-ловушку?</strong></p>
<p>Потому что может сработать не та ловушка.</p>
<p><strong>92. Напишите конструкцию, которая позволяет перехватить любое исключение.</strong></p>
<p>catch(&#8230;){}</p>
<p><strong>93. Могут ли контролируемые блоки быть вложенными?</strong></p>
<p>Да.</p>
<p><strong>94. Зачем нужен «контролируемый блок-функция» и чем он отличается от обычного контролируемого блока?</strong></p>
<p>Нужен для перехвата исключения в списке инициализации конструктора. Используется для преобразования типа исключения: ловится одно, кидается другое.</p>
<p>class X {</p>
<p>        vector v;</p>
<p>public:</p>
<p>        explicit X(int);</p>
<p>};</p>
<p>X::X(int s)</p>
<p>try</p>
<p>        :v(s)</p>
<p>{</p>
<p>        //&#8230;</p>
<p>}</p>
<p>catch(bad_alloc)</p>
<p>{</p>
<p>        //&#8230;</p>
<p>}</p>
<p><strong>95. Перечислите возможные способы выхода из блока обработки.</strong></p>
<p>Нормальный выход, генерация исключения, передача сгенерированного исключения.</p>
<p><strong>96. Каким образом исключение «передать дальше»?</strong></p>
<p>throw</p>
<p><strong>97. Сколько секций-ловушек должно быть задано в контролируемом блоке?</strong></p>
<p>Сколько угодно. Главное &#8211; правильная последовательность.</p>
<p><strong>98. Что такое «спецификация исключений»?</strong></p>
<p>Это часть объявления функции, которая указывает набор генерируемых ею исключений и производных от них.</p>
<p>void fu(int a) throw(x2, x3);</p>
<p><strong>99. Что происходит, если функция нарушает спецификацию исключений?</strong></p>
<p>вызовется std::unexpected() и программа завершит работу terminate().</p>
<p><strong>100. Учитывается ли спецификация исключений при перегрузке функций?</strong></p>
<p>Спецификация должна быть не менее строгой.</p>
<p>Потомок может генерировать производные исключения.</p>
<p><strong>101. Что такое «иерархия исключений»?</strong></p>
<p>То же, что иерархия классов.</p>
<p><strong>102. Существуют ли стандартные исключения? Назовите два-три типа стандартных исключений.</strong></p>
<p>Да.</p>
<p>exception      <- logic_error         <- domain_error</p>
<p>                                                             <- invalid_argument</p>
<p>                                                             <- length_error</p>
<p>                                                             <- out_of_range</p>
<p>                       <- runtime_error       <- range_error</p>
<p>                                                             <- overflow_error</p>
<p>                                                             <- underflow_error</p>
<p><strong>103. Поясните «взаимоотношение» исключений и деструкторов.</strong></p>
<p>Объект уничтожается в конце его области видимости, если сгенерировалось исключение. Деструктор отрабатывает.</p>
<p><strong>104. Объясните, зачем может понадобиться подмена стандартных функций завершения.</strong></p>
<p>Для собственной обработки ситуаций (обычно для записи в лог).</p>
<p><strong>105. Какие виды нестандартных исключений вы знаете?</strong></p>
<p>Нестандартные &#8211; потому что не успели включить в стандарт?</p>
<p><strong>106. В чем отличие механизма структурной обработки исключений Windows от стандартного механизма?</strong></p>
<p>этот механизм называется SEH. предоставляет две схемы обработки. __try{} __except{} и __try{} __finally{}</p>
<p>в SEH существует только единственный обработчик.</p>
<p>Описано у Рихтера.</p>
<p><strong>107. Какие две роли выполняет наследование?</strong></p>
<p>Формирует иерархию и поощряет повторное использование кода.</p>
<p><strong>108. Какие виды наследования возможны в С++?</strong></p>
<p>Обычное, множественное, виртуальное.</p>
<p><strong>109. Чем отличается модификатор доступа protected от модификаторов private и public?</strong></p>
<p>Видимостью наследующему классу.</p>
<p><strong>110. Чем открытое наследование отличается от закрытого и защищенного?</strong></p>
<p>Имя класса может использоваться в разных местах.</p>
<p><strong>111. Какие функции не наследуются? Почему?</strong></p>
<p>Конструкторы и оператор присваивания. Потому что если они не определены, они генерируются компилятором.</p>
<p><strong>112. Сформулируйте правила написания конструкторов в производном классе.</strong></p>
<p>Если базовый класс имеет конструктор, он должен быть вызван.</p>
<p><strong>113. Каков порядок вызова конструкторов? А деструкторов?</strong></p>
<p>В обратном порядке: (стек)</p>
<p>        Базовые виртуальные классы</p>
<p>        Таблица виртуальных классов.</p>
<p>        Базовые классы.</p>
<p>        Таблица виртуальных функций.</p>
<p>        Члены</p>
<p>        Сам класс</p>
<p>У деструктора наоборот</p>
<p><strong>114. Можно ли в производном классе объявлять новые поля? А методы?</strong></p>
<p>Да. Да.</p>
<p><strong>115. Если имя нового поля совпадает с именем унаследованного, то каким образом разрешить конфликт имен?</strong></p>
<p>Оператор доступа к области видимости ::</p>
<p><strong>116. Что происходит, если имя метода-наследника совпадает с именем базового метода?</strong></p>
<p>Происходит перекрытие имён.</p>
<p><strong>117. Сформулируйте принцип подстановки.</strong></p>
<p>Замена в программе объектов некоторого типа на объекты подтипа этого типа не должна приводить к изменениям в поведении программы.</p>
<p>Также подразумевается, что методы подкласса не могут выбрасывать исключений, кроме подклассов исключений, выбрасываемых базовым типом.</p>
<p>Функции, которые используют ссылки на базовые классы, должны иметь возможность использовать объекты производных классов, не зная об этом.</p>
<p><strong>118. Когда выполняется понижающее приведение типов?</strong></p>
<p>Когда у программы плохой дизайн <img src='http://www.fulcrumweb.com.ua/ukr/wp-includes/images/smilies/icon_smile.gif' alt=':)' class='wp-smiley' /> </p>
<p>При передаче в функцию объекта подтипа базового.</p>
<p><strong>119. Объясните, что такое «срезка» или «расщепление».</strong></p>
<p>Случай, когда в присваивании участвует два объекта из разных уровней одной иерархии. Одному из объектов присваивается только базовая часть (то, что он знает) от другого объекта.</p>
<p>Или, например, передача по значению в функцию класса наследника.</p>
<p><strong>120. Объясните, зачем нужны виртуальные функции.</strong></p>
<p>Для реализации динамического полиморфизма.</p>
<p><strong>121. Что такое связывание?</strong></p>
<p>Определение того, какая функция должна быть вызвана. То есть, компоновка.</p>
<p>Тип связывания или тип компоновки определяет соответствие имени объекту или функции в программе, исходный текст которой располагается в нескольких модулях. Различают статическое и динамическое связывание.</p>
<p>Статическое связывание бывает внешним или внутренним. Оно обеспечивается на стадии формирования исполнительного модуля, ещё до этапа выполнения программы.</p>
<p>Если объект локализован в одном модуле, то используется внутреннее связывание. Тип компоновки специальным образом не обозначается, а определяется компилятором по контексту, местоположению объявлений и использованию спецификаторов класса памяти.</p>
<p>Внешнее связывание выполняется компоновщиком, который на этапе сборки многомодульной программы устанавливает связь между уникальным объектом и обращениями к объекту из разных модулей программы.</p>
<p>При динамическом связывании компоновщик не имеют никакого представления о том, какой конкретно объект будет соответствовать данному обращению. Динамическое связывание обеспечивается транслятором в результате подстановки специального кода, который выполняется непосредственно в ходе выполнения программы.</p>
<p>В Си глобальные переменные по умолчанию имеют внутреннее связывание. В си-плюсплюс &#8211; наоборот, внешнее. И то и другое, разумеется, если квалификатор не задан явно.</p>
<p>Ключевое слово extern выводит за пределы области видимости единицы трансляции.</p>
<p><strong>122. Чем «раннее» связывание отличается от «позднего»?</strong></p>
<p>На этапе компиляции &#8211; разрешение перегрузки. На этапе выполнения &#8211; виртуальные функции.</p>
<p><strong>123. Какие два вида полиморфизма реализованы в С++?</strong></p>
<p>Статический и динамический. Шаблоны и виртуальные функции.</p>
<p><strong>124. Дайте определение полиморфного класса.</strong></p>
<p>Класс с виртуальными функциями.</p>
<p><strong>125. Может ли виртуальная функция быть дружественной функцией класса?</strong></p>
<p>Да.</p>
<p><strong>126. Наследуются ли виртуальные функции?</strong></p>
<p>Да.</p>
<p><strong>127. Каковы особенности вызова виртуальных функций в конструкторах и деструкторах?</strong></p>
<p>В конструкторе не работают. Потому что объект ещё до конца не создан, следовательно нет таблицы виртуальных функций.</p>
<p><strong>128. Можно ли сделать виртуальной перегруженную операцию, например, сложение?</strong></p>
<p>Да.</p>
<p><strong>129. Может ли конструктор быть виртуальным? А деструктор?</strong></p>
<p>Нет. Да.</p>
<p><strong>130. Как виртуальные функции влияют на размер класса?</strong></p>
<p>Указатель на таблицу виртуальных функций для каждого объекта. Таблица виртуальных функций для каждого класса. В целом &#8211; никак.</p>
<p><strong>131. Как объявляется «чистая» виртуальная функция?</strong></p>
<p>Присваивается 0.</p>
<p>class A { virtual void d() = 0; }</p>
<p><strong>132. Дайте определение абстрактного класса.</strong></p>
<p>Класс, содержащий только чистые виртуальные функции.</p>
<p><strong>133. Наследуются ли чистые виртуальные функции?</strong></p>
<p>Да.</p>
<p><strong>134. Можно ли объявить деструктор чисто виртуальным?</strong></p>
<p>Да. Деструктор должен быть определён.</p>
<p><strong>135. Чем отличается чистый виртуальный деструктор от чистой виртуальной функции?</strong></p>
<p>Он обязан иметь определение.</p>
<p><strong> </strong></p>
<p><strong>136. Зачем требуется определение чистого виртуального деструктора?</strong></p>
<p>Чтобы корректно удалять объекты по ссылке типа базового класса.</p>
<p>Например, если это единственный метод, а создание класса нужно запретить.</p>
<p><strong>137. Наследуется ли определение чистой виртуальной функции?</strong></p>
<p>Нет. У чистой виртуальной функции нет смысла в определении.</p>
<p><strong>138. Приведите классификацию целей наследования.</strong></p>
<p>Наследование интерфейса и наследование реализации.</p>
<p><strong>139. Объясните разницу наследования интерфейса от наследования реализации.</strong></p>
<p>В первом случае наследуются объявления функций, во втором &#8211; поля и алгоритмы.</p>
<p><strong>140. Назовите причины, требующие разделения программ на части.</strong></p>
<p>Уменьшение времени на компиляцию, борьба со сложностью, ODR.</p>
<p><strong>141. Дайте определение термина «единица трансляции»?</strong></p>
<p>Результат обработки препроцессором исходного файла с кодом.</p>
<p><strong>142. Чем отличается файл с исходным текстом от единицы трансляции?</strong></p>
<p>Первое &#8211; это то, что видит программист. Второе &#8211; то, что обрабатывает компилятор.</p>
<p><strong>143. Существуют ли в С++ конструкции, позволяющие идентифицировать отдельный модуль?</strong></p>
<p>Пространство имён, неименованное пространство имён.</p>
<p><strong>144. Какие способы сборки программы вы можете назвать?</strong></p>
<p>Полная перекомпоновка и частичная сборка.</p>
<p><strong>145. Что такое «объектный модуль»? Программа, которая «собирает» объектные модули в программу, называется _____________ ?</strong></p>
<p>Транслированный код единицы трансляции с таблицами экспорта.</p>
<p>Линковщик.</p>
<p><strong>146. В чем заключается отличие аргумента «файл» от <файл> в директиве #include?</strong></p>
<p>Локальные и глобальные подключения.</p>
<p><strong>147. Что такое ODR?</strong></p>
<p>Правило одного определения. One definition rule. Каждый пользовательский тип должен быть определён в программе ровно один раз.</p>
<p><strong>148. Объясните, что такое «страж» включения и зачем он нужен.</strong></p>
<p>Это конструкция из #ifdef SYMBOL</p>
<p>Нужна для предотвращения повторного включения и соблюдения ODR</p>
<p><strong>149. Является ли интерфейс класса его определением?</strong></p>
<p>Нет. Это его объявление.</p>
<p><strong>150. Сколько определений класса может быть в единице трансляции?</strong></p>
<p>Одно.</p>
<p><strong>151. Сколько определений класса может быть в многофайловой программе?</strong></p>
<p>Несколько, если они идентичны.</p>
<p><strong>152. Чем отличаются стандартные заголовки <string>, <string.h> и <cstring>?</strong></p>
<p>STL, CRT, MFC</p>
<p><strong>153. Объясните суть идиомы Pimpl.</strong></p>
<p>В классе хранится указатель на реализацию. Реализация скрыта от пользователя.</p>
<p><strong>154. Что такое делегирование и как его можно использовать для повышения степени инкапсуляции?</strong></p>
<p>Это спецификация множества операций, которые не определены для одного класса и должны обслуживаться другим. Можно хранить указатель на другой класс и ссылаться на него в функциях.</p>
<p>Разделяет сферы ответственности.</p>
<p><strong>155. Каким образом глобальную переменную, определенную в одной единице трансляции, сделать доступной в другой единице трансляции? А константу?</strong></p>
<p>определение int x = 10; доступность extern int x;</p>
<p>определение extern const int x = 10; доступность extern const int x;</p>
<p><strong>156. Можно ли использовать слово extern при объявлении функций?</strong></p>
<p>Да.</p>
<p><strong>157. Как локализовать объявление функции в файле?</strong></p>
<p>Использовать static(внутреннюю компоновку) или неименованные пространства имён(предпочтительно)</p>
<p><strong>158. Чем отличается «внешнее» связывание от «внутреннего» связывания?</strong></p>
<p>Внутренее связывание происходит тогда, когда объект локализован в одном модуле.</p>
<p>Внешнее связывание &#8211; установка линкером связи между объектом и обращениями к нему.</p>
<p><strong>159. Что такое «спецификации компоновки»?</strong></p>
<p>Нотация, позволяющая компоновать объектные модули, написанные на разных языках программирования.</p>
<p>Например, соглашения о вызове функций(порядке помещения параметров в стек).</p>
<p><strong>160. Какие объекты обладают внутренним связыванием по умолчанию?</strong></p>
<p>Неглобальные переменные</p>
<p><strong>161. Какие области видимости имен вы знаете?</strong></p>
<p>Глобальная, в пределах единицы трансляции, в пределах класса, в пределах функции, в пределах тела цикла.</p>
<p><strong>162. Для чего используются пространства имен?</strong></p>
<p>Для управления сложностью и разделения программы на части. Для избегания глобальных переменных.</p>
<p><strong>163. Чем отличаются именованные и неименованные пространства имен?</strong></p>
<p>В неименованных namespaces доступ к объявленным в них именам возможен только из той же единицы трансляции, где определено namespace.</p>
<p><strong>164. Могут ли пространства имен быть вложенными?</strong></p>
<p>Да.</p>
<p><strong>165. Для чего применяются алиасы пространства имен?</strong></p>
<p>Для удобства использования и чтобы избежать конфликта имён.</p>
<p><strong>166. Как сделать члены пространства имен доступными в нескольких (в пределе —</strong> во всех) файлах программного проекта?</p>
<p>using namespace xxx;</p>
<p><strong>167. Объясните разницу между статической и динамической инициализацией.</strong></p>
<p>Значение известно на этапе компиляции/выполнения.</p>
<p><strong>168. В чем состоит проблема инициализации глобальных статических переменных?</strong></p>
<p>В том, что порядок инициализации неизвестен.</p>
<p><strong>169. Какие элементы класса можно объявлять статическими?</strong></p>
<p>Методы, операторы, члены</p>
<p><strong>170. Можно ли объявить в классе статическую константу? А константный</strong> статический массив?</p>
<p>Да. Да.</p>
<p><strong>171. А какие статические поля можно инициализировать непосредственно в</strong> <strong>классе?</strong></p>
<p>Статические интегральные константы.</p>
<p><strong>172. Как определяются статические поля? В какой момент работы программы</strong> <strong>выполняется инициализация статических полей?</strong></p>
<p>ключевое слово static</p>
<p>до вызова main</p>
<p><strong>173. Сколько места в классе занимают статические поля ?</strong></p>
<p>0</p>
<p><strong>174. Чем отличается статический метод от обычного?</strong></p>
<p>нет this</p>
<p><strong>175. Какие методы класса не могут быть статическими?</strong></p>
<p>Конструкторы, деструкторы, виртуальные функции</p>
<p><strong>176. Какие применения статических полей вы можете привести? А каким образом применяются статические методы?</strong></p>
<p>Счётчик экземпляров. Состояние класса.</p>
<p>Функция, создающая объекты.</p>
<p><strong>177. Приведите структуру и принцип действия паттерна Singleton.</strong></p>
<p>Класс с приватным конструктором. Имеет функцию для возврата объекта. Хранит объект в себе.</p>
<p>Общая проблема реализации паттерна &#8211; время жизни.</p>
<p><strong>178. Для чего предназначены шаблоны?</strong></p>
<p>Для реализации типонезависимых алгоритмов и для метапрограммирования.</p>
<p><strong>179. Какие виды шаблонов в С++ вы знаете?</strong></p>
<p>Шаблоны классов и шаблоны функций.</p>
<p><strong>180. Объясните термин «инстанцирование шаблона».</strong></p>
<p>Процесс генерации объявления по шаблону.</p>
<p><strong>181. В чем разница между определением и объявлением шаблона?</strong></p>
<p>В том же, что и между определением и объявлением функции или класса.</p>
<p><strong>182. Объясните назначение ключевого слова typename.</strong></p>
<p>Чтобы заявить о том, что именованная сущность &#8211; это тип. Используется, чтобы указать на вложенный в шаблоне тип, зависящий от параметра шаблона.</p>
<p>Может быть использовано вместо слова class в объявлении шаблона.</p>
<p><strong>183. Какие виды параметров разрешается задавать в шаблоне класса? А в шаблоне</strong> <strong>функции?</strong></p>
<p>Типы(typename, class), обычные типы(int), шаблоны</p>
<p><strong>184. Можно ли параметрам шаблона присваивать значения по умолчанию?</strong></p>
<p>Да.</p>
<p><strong>185. Может ли параметром шаблона быть другой шаблон? Каковы особенности объявления параметра-шаблона?</strong></p>
<p>Да.</p>
<p>Нужно знать тип инстанцирования шаблона.</p>
<p><strong>186. Что такое специализация шаблона? Объясните разницу между полной и частичной специализацией.</strong></p>
<p>Частный случай некоторого шаблона при фиксированной части аргументов. Частичная специализация &#8211; часть аргументов фиксирована. Полная &#8211; все аргументы фиксированы.</p>
<p><strong>187. Разрешается ли специализировать шаблон функции?</strong></p>
<p>Да, но только полностью. Частичная специализация &#8211; это перегрузка.</p>
<p><strong>188. Может ли класс-шаблон быть вложенным в другой класс-шаблон? А в обычный класс?</strong></p>
<p>Да. Да.</p>
<p><strong>189. Можно ли объявить в классе шаблонный метод? А шаблонный конструктор?</strong></p>
<p>Да. Да.</p>
<p><strong>190. Можно ли перегружать функцию-шаблон?</strong></p>
<p>Да.</p>
<p><strong>191. Какие параметры функции-шаблона выводятся автоматически?</strong></p>
<p>Простые типы. Если совпадение с типом элементов аргумента массива.</p>
<p><strong>192. Может ли шаблон класса быть наследником обычного класса? А обычный класс от шаблона?</strong></p>
<p>Да. Нет.</p>
<p><strong>193. Объясните, что такое класс свойств (класс трактовок).</strong></p>
<p>Параметры шаблонов, используемые для выбора того или иного алгоритма.</p>
<p><strong>194. Каким образом можно использовать возможность наследования обычного класса от шаблона?</strong></p>
<p>Создавать типонезависимые интерфейсы к внутреннему средству.</p>
<p><strong>195. Может ли шаблонный конструктор быть конструктором по умолчанию?</strong></p>
<p>Нет.</p>
<p><strong>196. Для чего применяются директивы явного инстанцирования?</strong></p>
<p>Чтобы соответствующий экземпляр был скомпилирован/слинкован. При объявлении инстанцированного типа.</p>
<p><strong>197. Объясните, в чем состоят проблемы, возникающие при разделении шаблонного класса на интерфейс и реализацию?</strong></p>
<p>Реализация не может быть вынесена в cpp файл (так как экспорт шаблонов не поддерживается большинством компиляторов)</p>
<p><strong>198. Что такое «модель явного инстанцирования» и как она работает?</strong></p>
<p>Реализация вынесена в cpp файл и есть явные экземпляры для нужных типов.</p>
<p>Например, template basic_string<char> string;</p>
<p><strong>199. Может ли шаблонный класс иметь «друзей»?</strong></p>
<p>Да.</p>
<p><strong>200. Какие проблемы возникают при объявлении дружественной функции для класса-шаблона?</strong></p>
<p>Заранее неизвестен тип, с которым ведётся работа.</p>
<p><strong>201. Разрешается ли определять в классе-шаблоне статические поля? А статические методы?</strong></p>
<p>Да. Да.</p>
<p><strong>202. Что такое «инициализация нулем»?</strong></p>
<p>Инициализация объекта значением 0, преобразованным в тип объекта.</p>
<p><strong>203. Что является единицей памяти в С++? Какие требования к размеру единицы памяти прописаны в стандарте С++?</strong></p>
<p>Байт. Это самая малая величина, достаточная для хранения самых маленьких базовых типов С++. Каждый байт &#8211; непрерывная последовательность бит, имеющая уникальный адрес.</p>
<p><strong>204. В каких единицах выдает результат операция sizeof? Какие типы данных имеют размер 1?</strong></p>
<p>В единицах char.</p>
<p>все виды char, пустой объект и указатель</p>
<p><strong>205. Какие три вида памяти входят в модель памяти С++?</strong></p>
<p>Статическая</p>
<p>Автоматическая(стек)</p>
<p>Свободная(куча)</p>
<p><strong>206. Сколько видов динамической памяти обеспечивает С++?</strong></p>
<p>Автоматическая и свободная(стек и куча)</p>
<p><strong>207. Какие функции для работы с динамической памятью достались С++ по наследству от С? В какую библиотеку они включены?</strong></p>
<p>семейство alloc и free</p>
<p>cstdlib</p>
<p><strong>208. Какие функции выделяют память, и с помощью каких функций память освобождается?</strong></p>
<p>malloc, free</p>
<p><strong>209. Какое важное отличие имеет функция calloc() от функции malloc()?</strong></p>
<p>Обнуление выделенной памяти.</p>
<p><strong>210. Какие действия выполняют функции выделения памяти, если память не может быть выделена?</strong></p>
<p>Возвращают NULL.</p>
<p><strong>211. Зависит ли объем выделенной памяти от типа указателя? Влияет ли выравнивание на объем выделяемой динамической памяти?</strong></p>
<p>Нет. Да.</p>
<p><strong>212. Можно ли с помощью функции realloc() уменьшить объем выделенной памяти?</strong></p>
<p>Да.</p>
<p><strong>213. Что произойдет, если функции free() передать в качестве аргумента нулевой указатель?</strong></p>
<p>Ничего.</p>
<p><strong>214. В чем главное отличие объектно-ориентированного механизма new/delete от механизма malloc()/free()?</strong></p>
<p>Он оперирует на уровне объектно-ориентированной абстракции, а не на машинном уровне. Машинная низкоуровневая модель рассматривает память как массив битов. Высокоуровневая модель, как объект.</p>
<p><strong>215. Сколько существует форм new/delete? В чем их отличие?</strong></p>
<p>new, new[], delete, delete[]</p>
<p>Возможность создавать массив объектов.</p>
<p>есть операторы с размещением, есть с параметром nothrow</p>
<p><strong>216. Какие типы являются POD-типами? Чем отличается работа механизма new/delete с POD-объектами и nonPOD-объектами?</strong></p>
<p>Plain old data. Те типы, которые есть в С. Классы или структуры, содержащие только POD-поля.</p>
<p>new X &#8211; не инициализируется</p>
<p>new X() &#8211; инициализируется</p>
<p><strong>217. Какие функции выполняет обработчик new?</strong></p>
<p>Пытается найти память в случае неудачи при помощи new_handler или просто возвращает исключение.</p>
<p><strong>218. Можно ли реализовать собственный обработчик new и «прицепить» его к механизму new/delete?</strong></p>
<p>Да. set_new_handler()</p>
<p><strong>219. В чем главное отличие объединения от других видов классов С++?</strong></p>
<p>Это структура, в которой все члены расположены по одному и тому же адресу.</p>
<p><strong>220. Может ли объединение участвовать в иерархии наследования? Что такое анонимное объединение?</strong></p>
<p>Нет. Объединение без имени, в области видимости структуры.</p>
<p><strong>221. Разрешается ли определять для объединения конструкторы и деструктор? А виртуальные функции?</strong></p>
<p>Нет. Нет.</p>
<p><strong>222. В чем похожи и чем отличаются объединение и размещающий new?</strong></p>
<p>Похожи моделью &#8220;конкретный кусок памяти &#8211; размещаю в нём, что хочу&#8221;. Отличаются &#8211; объединение интерпретирует кусок памяти по-разному.</p>
<p><strong>223. Объясните, почему при использовании размещающего new нужно явным образом вызывать деструктор?</strong></p>
<p>Потому что мы помещаем объект в область, которая явно не управляется стандартным распределителем памяти.</p>
<p><strong>224. Зачем нужны интеллектуальные указатели?</strong></p>
<p>Для облегчения управления памятью.</p>
<p>Для реализаций стратегий владения.</p>
<p><strong>225. Что такое «стратегия владения»? Сколько стратегий владения вы знаете?</strong></p>
<p>Способ, которым умные указатели ссылаются на объект</p>
<p>        Глубокое копирование &#8211; копирование объекта, на который он ссылается</p>
<p>        копирование при записи &#8211; копирование объекта происходит только при первой попытке его модификации</p>
<p>        подсчёт ссылок &#8211; подсчёт указателей, ссылающихся на объект. когда 0 &#8211; сборка мусора</p>
<p>        разрушающее копирование &#8211; можно быть уверенным, что если в вызывающем модуле значение не используется, оно уничтожается.</p>
<p>        связывание ссылок &#8211; нет необходимости считать указатели, получается список владельцев(полезно при недостатке динамической памяти).</p>
<p><strong>226. Какой интеллектуальный указатель реализован в стандартной библиотеке STL, и какую стратегию владения он реализует?</strong></p>
<p>auto_ptr, разрушающее копирование</p>
<p><strong>227. Объясните, в чем преимущества и недостатки интеллектуальных указателей со счетчиком ссылок.</strong></p>
<p>Простая стратегия. Потеря скорости и неэффективность работы с памятью.</p>
<p><strong>228. Разрешается ли перегружать new и delete и какими способами?</strong></p>
<p>Разрешается. Локально, в классе и глобально.</p>
<p><strong>229. Опишите схему функции, перегружающей глобальную функцию new.</strong></p>
<p>void *operator new(size_t size(){}</p>
<p>void operator delete[](void *p);</p>
<p><strong>230. Отличается ли реализация перегруженной функции new[]() для массивов от реализации «обычной» функции new()?</strong></p>
<p>Да. Указатель на объект отличается от указателя на первый элемент массива, как в С.</p>
<p><strong>231. Как вы думаете, почему функции new/delete, перегружаемые для класса, являются статическими?</strong></p>
<p>Потому что они выделяют память для объекта, то есть, создают его.</p>
<p><strong>232. Зачем при перегрузке new/delete для класса нужно проверять размер запрашиваемой памяти?</strong></p>
<p>Потому что операторы наследуются и могут быть вызваны потомками.</p>
<p><strong>233. Объясните, чем определяется «динамичность» контейнеров?</strong></p>
<p>Распределителями памяти? Что за вопрос вообще?</p>
<p><strong>234. Что такое «стратегия распределения памяти», и какие стратегии выделения памяти вы знаете?</strong></p>
<p>Алгоритм выделения блоков памяти.</p>
<p>Первый походящий, последний подходящий, наиболее подходящий.</p>
<p><strong>235. Рассмотрите следующую стратегию распределения памяти: память выделяется для нескольких элементов блоками фиксированной длины, но блоки связываются в список. Для какого вида контейнера можно использовать такую стратегию?</strong></p>
<p>list</p>
<p><strong>236. Какие операции можно перегрузить для доступа к элементам двумерного массива?</strong></p>
<p>()</p>
<p><strong>237. В чем заключаются сложности использования операции индексирования [] для доступа к элементам двумерного массива?</strong></p>
<p>Необходимо знать размеры массива по обе стороны</p>
<p><strong>238. Каковы способы реализации операций с контейнерами?</strong></p>
<p>алгоритм+итератор+функтор</p>
<p><strong>239. Какую конструкцию можно назвать «обобщенный алгоритм»?</strong></p>
<p>Шаблон.</p>
<p><strong>240. Каким образом объявить указатель на метод?</strong></p>
<p>typedef char* (Someclass::*func_ptr)(int, char*);</p>
<p><strong>241. Объясните разницу между указателем на функцию и указателем на метод.</strong></p>
<p>Указатель на функцию &#8211; глобально. Указатель на метод &#8211; для конкретного типа. Указатели на методы с одинаковой сигнатурой, но для разных типов являются разными указателями.</p>
<p><strong>242. Каким образом получить адрес метода?</strong></p>
<p>&amp;Class::somefunc;</p>
<p><strong>243. Можно ли указателю на функцию присваивать адрес метода?</strong></p>
<p>Нет.</p>
<p><strong>244. Какие операции определены в С++ для косвенного вызова метода через указатель?</strong></p>
<p>.* ->*</p>
<p><strong>245. Что такое «функтор»? Приведите пример функционального класса.</strong></p>
<p>Объект, который рассматривается, как функция. Объект класса с оператором ().</p>
<p>class Functor</p>
<p>{</p>
<p>        bool operator()(int x) {return static_cast<bool>(x);}</p>
<p>};</p>
<p><strong>246. Какими способами функтор вызывается?</strong></p>
<p>Передача в качестве параметра и как функция.</p>
<p><strong>247. Можно ли использовать наследование при разработке функторов?</strong></p>
<p>Да.</p>
<p><strong>248. Разрешается ли операцию вызова функции () определять как виртуальный метод? А как статический?</strong></p>
<p>Да. Нет.</p>
<p><strong>249. В чем преимущества функторов перед указателями на функции?</strong></p>
<p>поддержка обобщённого программирования</p>
<p>сохранение данных между вызовами, плюс операции инициализации этих данных</p>
<p>операцию () проще сделать встроенной, чем указатель на функцию</p>
<p><strong>250. Объясните, зачем нужны адаптеры функторов? Какие виды адаптеров вы знаете?</strong></p>
<p>Решают задачу, когда нужен новый предикат, который во многом похож на старый.</p>
<p>Связыватель, адаптер методов, адаптер указателя на функцию, отрицатель</p>
<p><strong>251. Как используются классы свойств при разработке функторов?</strong></p>
<p>Позволяют настраивать функтор.</p>
<p><strong>252. Объясните, что такое «композиция» и приведите примеры?</strong></p>
<p>Это один из способов реализации отношения &#8220;содержит&#8221;. Сделать один класс членом другого. Через закрытое наследование &#8211; другой способ. Отношения &#8220;является&#8221; &#8211; открытое наследование.</p>
<p><strong>253. Объясните, чем отличается множественное наследование от простого?</strong></p>
<p>Один родитель и много родителей.</p>
<p><strong>254. Приведите структуру и принцип действия паттерна Adapter.</strong></p>
<p>Паттерн вносит ограничения или привносит функциональность в сущность, адаптируя её под работу в конкретных условиях.</p>
<p><strong>255. Сформулируйте основную проблему множественного наследования.</strong></p>
<p>Проблема неоднозначности и совокупного хранения нескольких объектов базового класса.</p>
<p>Комбинаторное по своей природе, множественное наследование нельзя применять для поддержки многовариантных систем.</p>
<p>Нарушает принцип подстановки.</p>
<p><strong>256. Выполняется ли принцип подстановки при открытом множественном</strong> наследовании?</p>
<p>Да, если наследование проведено корректно.</p>
<p><strong>257. Что такое виртуальное наследование? Каковы его преимущества и недостатки по сравнению с обычным наследованием?</strong></p>
<p>Это множественное наследование, при котором нескольким классам, имеющим один базовый всегда сопоставляется один объект этого базового класса.</p>
<p>Преимущества &#8211; экономия памяти.</p>
<p><strong>258. Может ли виртуальное наследование быть одиночным?</strong></p>
<p>Да.</p>
<p><strong>259. Влияет ли виртуальное наследование на размер класса?</strong></p>
<p>Да. Уменьшает размер итогового класса.</p>
<p><strong>260. Объясните, каким образом с помощью виртуального наследования можно вообще запретить наследование.</strong></p>
<p>class my_class;</p>
<p>class nonderivable</p>
<p>{</p>
<p>        friend class my_class;</p>
<p>private:</p>
<p>        nonderivable() { }</p>
<p>};</p>
<p>class my_class: public virtual nonderivable</p>
<p>{</p>
<p>public:</p>
<p>        my_class(){}</p>
<p>};</p>
<p>class DD: public my_class { };</p>
<p>int main()</p>
<p>{</p>
<p>        my_class a;</p>
<p>        DD dd; // error</p>
<p>        return 0;</p>
<p>}</p>
<p><strong>261. Какие средства С++ составляют RTTI?</strong></p>
<p>dynamic_cast, typeid</p>
<p><strong>262. Объясните разницу между повышающим, понижающим и перекрестным приведением.</strong></p>
<p>Приведение к базовому типу, к потомку, к родственному классу в иерархии</p>
<p><strong>263. Какими свойствами должен обладать класс, чтобы с ним работал механизм RTTI?</strong></p>
<p>Быть полиморфным типом.</p>
<p><strong>264. В чем приведение указателей отличается от приведения ссылок?</strong></p>
<p>dynamic_cast генерирует исключение, если ссылка, если указатель, то просто возвращает 0</p>
<p><strong>265. Какие исключения связаны с механизмом RTTI?</strong></p>
<p>Можно отлавливать целую группу исключений и определять, что это за подтип базового типа при помощи dynamic_cast</p>
<p><strong>266. Что такое «поток» — дайте определение.</strong></p>
<p>Часть процесса, выполняющаяся параллельно (или псевдопараллельно).</p>
<p>Средство ввода-вывода С++</p>
<p><strong>267. Как классифицируются потоки, реализованные в библиотеках ввода/вывода С++?</strong></p>
<p>По направлению: ввод, вывод</p>
<p>По типу объекта: строковые, файловые</p>
<p><strong>268. Что такое буферизация и зачем она нужна?</strong></p>
<p>Это техника оптимизации, заключающаяся в накапливании достаточно большой порции данных и последующей их передаче на обработку.</p>
<p><strong>269. Какие библиотеки ввода/вывода реализованы в С++ и чем они отличаются?</strong></p>
<p><iostream> &#8211; ОО модель</p>
<p><cstdio> &#8211; С модель</p>
<p><strong>270. Перечислите стандартные потоки и объясните их назначение.</strong></p>
<p>stdin, stdout, stderr</p>
<p>идентификаторы 0,1,2</p>
<p><strong>271. Зачем нужен процесс форматирования и когда он выполняется?</strong></p>
<p>Он нужен для ввода-вывода данных с наложенными на них ограничениями. Выполняется тогда, когда мы работаем с данными ожидаемой структуры.</p>
<p><strong>272. Что такое «форматная строка», и в каких функциях она используется?</strong></p>
<p>Строка, задающая формат интерпретации переменных. Используется в вводе-выводе в стиле С.</p>
<p><strong>273. Объясните назначение элементов спецификатора формата.</strong></p>
<p>указывают тип, поля и точность вывода</p>
<p>% &#8211; указывает, что следующий за ним символ будет спецификатором формата</p>
<p>g &#8211; точность вывода числа с плавающей точкой определяется реализацией</p>
<p>e &#8211; научный формат вывода</p>
<p>f &#8211; фиксированный знак после запятой</p>
<p>i &#8211; целое число</p>
<p>c &#8211; символ</p>
<p>s &#8211; строка</p>
<p><strong>274. Сколько спецификаторов формата может быть в форматной строке?</strong></p>
<p>Сколько угодно (на сколько памяти хватит)</p>
<p><strong>275. Какой из элементов спецификатора формата не является умалчиваемым?</strong></p>
<p>Ширина поля #</p>
<p><strong>276. Перечислите несколько известных вам обозначений типов в спецификаторе формата, и укажите их назначение.</strong></p>
<p>g &#8211; точность вывода числа с плавающей точкой определяется реализацией</p>
<p>e &#8211; научный формат вывода</p>
<p>f &#8211; фиксированный знак после запятой</p>
<p>i &#8211; целое число</p>
<p>c &#8211; символ</p>
<p>s &#8211; строка</p>
<p><strong>277. Сколько модификаторов типа вы знаете, и какую роль модификатор типа играет в спецификаторе формата?</strong></p>
<p>c,d,i,o,x,f,e,g</p>
<p><strong>278. С помощью какого флага можно выровнять выводимое значение влево? А каким образом вывести ведущие нули?</strong></p>
<p>ios_base::left</p>
<p>ios_base::showpoint</p>
<p><strong>279. Какое действие оказывают на выводимую строку ширина, точность и флаги в спецификаторе формата?</strong></p>
<p>Ширина &#8211; не менее стольки-то симолов. Точность &#8211; забивает нулями недостаток, флаги &#8211; выравнивают</p>
<p><strong>280. Для чего в спецификаторе формата может использоваться символ звездочка («*»)? Чем отличается действие этого символа при воде и при выводе?</strong></p>
<p>Ширина поля. При вводе &#8220;не менее стольки-то&#8221; при выводе обрезает.</p>
<p><strong>281. Каковы особенности ввода строк?</strong></p>
<p>Если вводить в массив символов, а не в str &#8211; риск переполнения.</p>
<p>Строка считывается до символа-разделителя, поэтому чтобы считать строку с пробелами, необходимо использовать getline()</p>
<p>Символы-разделители определяются isspace(), которая определена в <cctype></p>
<p><strong>282. Каким образом ограничить набор вводимых символов при вводе?</strong></p>
<p>get(буфер, количество символов)</p>
<p>или через строковые потоки &#8211; применить флаг</p>
<p><strong>283. Что является главной проблемой при использовании форматного ввода/вывода из библиотеки <cstdio>?</strong></p>
<p>Переполнение буфера, так как это функции с переменным количеством аргументов.</p>
<p><strong>284. Объясните, для чего нужны строковые потоки. Почему строковые потоки &#8211; всегда форматируемые?</strong></p>
<p>Для форматирования в памяти.</p>
<p><strong>285. С помощью каких функций выполняется работа со строковыми потоками?</strong></p>
<p>operator<< operator>></p>
<p><strong>286. Можно ли использовать тип string (и каким образом) со строковыми потоками?</strong></p>
<p>Получить итоговую строку.</p>
<p><strong>287. Объясните, в чем заключается различие между текстовым и двоичным файлом.</strong></p>
<p>В интерпретации содержимого. Двоичный файл &#8211; &#8220;сырые данные&#8221;, свободная интерпретация. Тестовый файл &#8211; определённая структура (фиксированный набор символов, символы-разделители, и.т.д.)</p>
<p>Текстовый файл можно интерпретировать, как двоичный, а вот двоичный, как текстовый &#8211; не всегда.</p>
<p><strong>288. Объясните, что означает «открыть» файл и «закрыть» файл?</strong></p>
<p>Связать файл с дескриптором, который обращается к буферу в памяти, куда подгружается содержимое файла с диска.</p>
<p>В двух словах &#8220;перекачать файл в память с диска.</p>
<p><strong>289. Каким образом внешний файл связывается с потоком?</strong></p>
<p>Созданием объекта класса.</p>
<p><strong>290. Можно ли один и тот же поток связать с разными файлами? А один и тот же файл с разными потоками?</strong></p>
<p>Нет. Да, с флагами общего доступа.</p>
<p><strong>291. Перечислите режимы открытия файла. Чем отличается режим “r” от режима “a”?</strong></p>
<p>r a w и их комбинации</p>
<p>первый читает, но не пишет, второй может читать и  добавлять в конец</p>
<p><strong>292. Какую роль в режиме открытия играет знак плюс («+»)?</strong></p>
<p>Добавление в конец</p>
<p><strong>293. В каких случаях необходимо следить за ситуацией «конец файла»? Каким способом это делается?</strong></p>
<p>Когда идёт поблоковое чтение. Специальной функцией или итератором, смотря что используется.</p>
<p><strong>294. Можно ли текстовый файл открыть как двоичный? А двоичный — как текстовый?</strong></p>
<p>Да.Да.</p>
<p><strong> </strong></p>
<p><strong>295. Какие функции ввода/вывода используются для обмена с текстовыми файлами?</strong></p>
<p>fprintf</p>
<p>fscanf</p>
<p><strong>296. Перечислите функции ввода/вывода для работы с двоичными файлами.</strong></p>
<p>fget</p>
<p>fput</p>
<p><strong>297. Какие функции реализованы в библиотеке <cstdio> для обеспечения прямого доступа к записям двоичного файла? Можно ли их использовать для работы с текстовыми файлами?</strong></p>
<p>fseek, fread, fwrite</p>
<p>Можно.</p>
<p><strong>298. Объясните назначение функции fseek().</strong></p>
<p>Передвигать текущую позицию чтения-записи в файле.</p>
<p><strong>299. Чем отличается функция ftell() от функции fgetpos()?</strong></p>
<p>Первая ищет смещение от начала потока, вторая может искать от конца, начала и текущей позиции.</p>
<p><strong> </strong></p>
<p><strong>300. Объясните, что означает «перенаправление» потока? Какие потоки можно перенаправлять и куда?</strong></p>
<p>Вывод данных на другое заданное устройство, нежели предполагалось вначале. поток ввода, поток вывода, поток ошибок. На любое блочное или символьное устройство, будь то терминал или файл. С точки зрения С++ &#8211; это копирование буфера.</p>
<p>любой в любой</p>
<p><strong>301. Каким образом перенаправление ввода можно использовать для ввода строк с пробелами?</strong></p>
<p>Перенаправить в стрингстрим.</p>
<p><strong>302. В чем преимущества объектно-ориентированной библитеки по сравнению с процедурной?</strong></p>
<p>Если имеется в виду вывод &#8211; безопасность с точки зрения типов и общий стиль для вывода как встроенных, так и пользовательских типов.</p>
<p><strong>303. В каких состояних может находиться поток? Каким образом отслеживается состояние «конец потока»?</strong></p>
<p>good, bad, fail</p>
<p>итератором</p>
<p><strong>304. Какие объектно-ориентированные потоки связаны со стандартными потоками?</strong></p>
<p>cin, cout, cerr, clog</p>
<p><strong>305. Чем отличаются объектно-ориентированные строковые потоки от процедурных строковых потоков?</strong></p>
<p>Нет опасности переполнения</p>
<p><strong>306. Каким образом строковые потоки можно использовать для ограничения ширины поля ввода? А можно ли с той же целью использовать строковые потоки <cstdio>?</strong></p>
<p><strong>задать width()</strong></p>
<p>Да. Спецификатор *</p>
<p><strong>307. Сравните средства форматирования объектно-ориентированной и процедурной библиотеки.</strong></p>
<p>ОО &#8211; манипуляторы. Действуют для потока.</p>
<p>ПРОЦ &#8211; строка форматирования. Действует для конкретного ввода.</p>
<p><strong>308. Каким образом ввести строку типа string с пробелами?</strong></p>
<p>Функция getline()</p>
<p><strong>309. Каково назначение флагов форматирования? Какие средства реализованы в библиотеке для работы с флагами форматирования?</strong></p>
<p>Управляют форматированием ввода-вывода.</p>
<p><strong>310. Что такое «манипулятор»? В чем преимущества манипуляторов перед флагами форматирования?</strong></p>
<p>Функция для установки состояния потока. Когда операции записываются, как инструкции, логические связи между ними не очевидны.</p>
<p><strong>311. Как связываются файлы с потоками в объектно-ориентированной библиотеке?</strong></p>
<p>Через конструктор и деструктор.</p>
<p><strong>312. Можно ли файлы, записанные функциями библиотеки <cstdio>, прочитать объектно-ориентированными средствами? А наоборот?</strong></p>
<p>Да. Да.</p>
<p><strong>313. Перечислите режимы открытия объектно-ориентированных файловых потоков. каким образом комбинируются режимы открытия файлоавых потоков?</strong></p>
<p>чтение, запись, добавление в конец, двоичный, поиск конца</p>
<p>побитовым &#8220;ИЛИ&#8221;</p>
<p><strong>314. Обязательно ли закрывать файл, связанный с объектно-ориентированным файловым потоком? А открывать?</strong></p>
<p>Достаточно создать объект класса потока.</p>
<p><strong>315. Каким образом открыть файловый поток для чтения и записи одновременно?</strong></p>
<p>объявить объект типа std::fstream и добавить соответствующие флаги.</p>
<p><strong>316. Как открыть файловый поток для дозаписи?</strong></p>
<p>ios_base app</p>
<p><strong>317. Можно ли вывести значение переменной в двоичном виде и как это сделать?</strong></p>
<p>int i = 938745;</p>
<p>cout << bitset<32>(i);</p>
<p>Или через флаги.</p>
<p><strong>318. Разрешается ли наследовать от классов библиотеки ввода/вывода?</strong></p>
<p>Да.</p>
<p><strong>319. Каким образом можно перенаправить объектно-ориентированный поток?</strong></p>
<p>class redirecter</p>
<p>{</p>
<p>public:</p>
<p>    redirecter(std::ostream &amp; dst, std::ostream &amp; src)</p>
<p>        : src(src), sbuf(src.rdbuf(dst.rdbuf())) {}</p>
<p>    ~redirecter() { src.rdbuf(sbuf); }</p>
<p>private:</p>
<p>    std::ostream &amp; src;</p>
<p>    std::streambuf * const sbuf;</p>
<p>};</p>
<p>int main()</p>
<p>{</p>
<p>    std::ofstream log(&#8220;hello-world.log&#8221;);</p>
<p>    redirecter redirect(log, std::cout);</p>
<p>    std::cout << "Hello, world!\n";</p>
<p>    return 0;</p>
<p>}</p>
<p><strong>320. Как используется буфер потока для копирования потока?</strong></p>
<p>ostream dst; istream src;</p>
<p>dst << src.rdbuf();</p>
<p><strong>321. Какими операциями выполняется форматированный ввод/вывод в файловые</strong> <strong>потоки? А неформатированный?</strong></p>
<p>fprintf, fscanf</p>
<p>fread, fwrite</p>
<p><strong>322. Реализованы ли в объектно-ориентированной библиотеке средства прямого доступа к файловым потокам? Сравните их с аналогичными средствами библиотеки <cstdio>.</strong></p>
<p>Да.</p>
<p><strong>323. С какими объектно-ориентированными потоками разрешается, и с какими не разрешается использовать средства прямого доступа?</strong></p>
<p>iostream &#8211; разрешено</p>
<p>stringstream &#8211; запрещено</p>
<p><strong>324. Покажите, каким образом можно выполнить перегрузку операций ввода/вывода для нового типа данных.</strong></p>
<p>class A</p>
<p>{</p>
<p>public:</p>
<p>        int getField(){return i;}</p>
<p>        int setField(int i) { this->i = i; }</p>
<p>        A(int i):i(i);</p>
<p>private:</p>
<p>        int i;</p>
<p>};</p>
<p>std::ostream&amp; operator<<(std::ostream&amp; s, A a) { s << a.getField(); return s; }</p>
<p>std::istream&amp; operator>>(std::istream&amp; s, A a) { int i = 0; s >> i; a.setField(i); return s; }</p>
<p><strong>325. Как выполняется обработка ошибок ввода/вывода в объектно-ориентированной библиотеке?</strong></p>
<p>Исключения или флаги состояния потока</p>
<p><strong>326. Какое стандартное исключение генерируется при ошибках ввода/вывода? Обязательно ли оно генерируется?</strong></p>
<p>ios_base::failure</p>
<p>не всегда. Надо попросить об этом, например, cout.extensions(ios_base::badbit|ios_base::eofbit);</p>
<p><strong>327. Чем стандартные широкие потоки отличаются от узких?</strong></p>
<p>Оперируют расширенными символами (юникод) wchar_t, например.</p>
<p><strong>328. Что такое — «локаль», и каково ее назначение?</strong></p>
<p>Объект, который контролирует классификацию символов и устанавливает порядок их следования.</p>
<p>Поддержка соглашений, принятых в другой культуре.</p>
<p><strong>329. Как установить русский шрифт при выводе в консольное окно?</strong></p>
<p>например:</p>
<p>locale loc(&#8220;ru_RU.UTF8&#8243;);</p>
<p>locale::global(loc);</p>
<p><strong>330. отличается ли ввод/вывод широких файловых потоков от узких? Чем?</strong></p>
<p>На уровне интерфейса &#8211; нет.</p>
<p><strong>331. Перечислите все последовательные контейнеры стандартной библиотеки. Чем они отличаются друг от друга?</strong></p>
<p>vector &#8211; непрерывная в памяти последовательность, операции с концом вектора и индексация О(1), вставка в середину O(n)</p>
<p>list &#8211; вставка в начало и конец за постоянное время, доступ к элементам за линейное</p>
<p>dequeue &#8211; вставка в оба конца за постоянное время, индексация приближённо как у вектора</p>
<p><strong>332. Перечислите адаптеры последовательных контейнеров и дайте их подробную характеристику.</strong></p>
<p>queue, stack, priority_queue</p>
<p><strong>333. Почему для адаптеров-очередей нельзя использовать вектор в качестве базового?</strong></p>
<p>У вектора нет pop_front</p>
<p><strong>334. Чем простая очередь queue отличается от приоритетной очереди priority_queue?</strong></p>
<p>В приоритетной очереди операция извлечения ориентируется не только на положение элемента, но и на результат операции сравнения.</p>
<p><strong>335. Каким требованиям должны удовлетворять элементы контейнера?</strong></p>
<p>Должна поддерживаться операция копирования, похожая на встроенные типы. Для ассоциативных контейнеров должно поддерживаться сравнение (по умолчанию <), определяющее строгое слабое упорядочивание.</p>
<p><strong>336. Могут ли быть указатели элементами контейнера? А итераторы?</strong></p>
<p>Да. Теоретически может, есть опасность получить неверный итератор.</p>
<p><strong>337. Почему нельзя использовать в качестве элементов контейнера стандартный интеллектуальный указатель auto_ptr?</strong></p>
<p>Потому что операция копирования auto_ptr зануляет исходный указатель</p>
<p><strong>338. Зачем в контейнере list реализованы собственные методы сортировки поиска и слияния? Можно ли пользоваться соответствующими стандартными алгоритмами при обработке списка?</strong></p>
<p>Потому что алгоритм sort требует итератора с произвольным доступом. Нельзя.</p>
<p><strong>339. Перечислите типовые виды конструкторов, с помощью которых можно создавать последовательный контейнер.</strong></p>
<p>Конструктор копирования, конструктор заполнения.</p>
<p><strong>340. Можно ли инициализировать контейнер элементами встроенного массива? А элементами другого контейнера? Какими способами это можно сделать?</strong></p>
<p>Да.Да.Шаблонным конструктором.</p>
<p><strong>341. Почему конструктор инициализации, параметрами которого являются итераторы, сделан шаблонным во всех контейнерах?</strong></p>
<p>Чтобы можно было инициализировать вектор из другой последовательности, например, из списка.</p>
<p><strong>342. Какие методы реализованы в контейнере-векторе для доступа к элементам?</strong></p>
<p>Операция индексации, итераторы начала и конца</p>
<p><strong>343. Отличается ли функция at() доступа по индексу от перегруженной операции индексирования и чем?</strong></p>
<p>Да. Проверкой границ доступа.</p>
<p><strong>344. Перечислите методы контейнера deque, относящиеся к определению размеров контейнера.</strong></p>
<p>empty</p>
<p>max_size</p>
<p>size</p>
<p><strong>345. Чем метод size() отличается от метода capacity()? А в чем отличие этих методов от метода max_size()?</strong></p>
<p>сколько хранит, сколько может хранить до изменения размера памяти, сколько вообще может хранить.</p>
<p><strong>346. Перечислите методы контейнера list, предназначенные для вставки удаления и замены элементов. Отличаются ли эти методы от соответствующих методов вектора и дека?</strong></p>
<p>insert</p>
<p>push_front</p>
<p>pop_front</p>
<p>push_back</p>
<p>pop_back</p>
<p>нет, только некоторых методов у вектора нет.</p>
<p><strong>347. Каким образом выполняются операции сравнения контейнеров?</strong></p>
<p>Для сравнения используется оператор <. Строгое слабое упорядочивание элементов. Алгоритмы equal и mismatch.</p>
<p><strong>348. Разрешается ли изменять элемент ассоциативного контейнера, доступный в данный момент по итератору?</strong></p>
<p>Да, но только значение. Тонкий момент: элемент &#8211; это пара &#8220;ключ-значение&#8221;, хранение происходит в порядке неубывания ключей.</p>
<p><strong>349. Какие контейнеры называются ассоциативными и почему?</strong></p>
<p>set, multiset, map, multimap. Потому что значение ищется не по порядковому номеру, а по ключу, ассоциируя значение с ключом.</p>
<p><strong>350. Чем контейнер map отличается от контейнера multimap?</strong></p>
<p>Можно хранить уникальные или неуникальные значения.</p>
<p><strong>351. Объясните, почему в ассоциативных контейнерах нельзя изменять элемент, доступный в данный момент по итератору.</strong></p>
<p>Можно безбоязненно изменять значение, но не ключ.</p>
<p><strong>352. По каким причинам в контейнере-множестве не реализованы типовые операции объединения, пересечения, разности и другие?</strong></p>
<p>Это было бы не универсально. Вместо этого реализованы соответствующие алгоритмы на операциях со множествами.</p>
<p>        set_union</p>
<p>        set_intersection</p>
<p>        set_difference</p>
<p>        set_symmetric_difference</p>
<p><strong>353. Как используется структура-пара в ассоциативных контейнерах?</strong></p>
<p>Как единица хранения данных.</p>
<p><strong>354. Объясните, что такое «критерий сортировки», и каким требованиям он должен удовлетворять? Какой критерий сортировки принят по умолчанию?</strong></p>
<p>Это оператор сравнивания. Он должен определить строгое слабое упорядочивание, меньше и равно должны быть транзитивными.</p>
<p><strong>355. Какими преимуществами обладает функция make_pair() по сравнению с конструктором pair()?</strong></p>
<p>Не надо указывать типы, они выводятся, так как это шаблон функции.</p>
<p><strong>356. Почему в контейнерах-отображениях операция индексирования перегружена, а в контейнерах-множествах — нет?</strong></p>
<p>Незачем.</p>
<p><strong>357. Какие гарантии безопасности обеспечивают контейнеры стандартной библиотеки?</strong></p>
<p>Вектор &#8211; базовую.</p>
<p>Остальные &#8211; не знаю.</p>
<p><strong>358. Что такое «транзакционная гарантия безопасности» и чем она отличается от базовой?</strong></p>
<p>Базовая гарантия &#8211; даже при наличии исключений, утечка ресурсов отсутствует.</p>
<p>Транзакционная гарантия &#8211; если операция прекращается, то состояние программы остаётся неизменным.</p>
<p>В транзакционной гарантии все ссылки и итераторы будут действительными, в базовой &#8211; нет.</p>
<p><strong>359. Можно ли с помощью алгоритма for_each() изменить элементы контейнера?</strong></p>
<p>Можно через функтор, который передаётся в алгоритм, создать новый контейнер с изменёнными элементами. Но в целом нельзя.</p>
<p><strong>360. Что такое «распределитель памяти» и зачем он нужен?</strong></p>
<p>Это абстракция. Любой тип, ведущий себя, как распределитель памяти, является им. Нужен для управления памятью для конкретного типа.</p>
<p>это чистая абстракция. объект класса. ключевые концепции &#8211; своя стратегия выделения памяти и избавление разработчика от необходимости иметь дело с сырой памятью.</p>
<p><strong>361. Чем отличается битовый вектор bitset от битового вектора vector<bool>?</strong></p>
<p>Поддерживает операции с битами, длина фиксирована. Проиндексирован. Итератор на vector<bool> не является булевым типом.</p>
<p><strong>362. Дайте определение итератора.</strong></p>
<p>Итератор &#8211; это чистая абстракция. Всё, что ведёт себя, как итератор &#8211; это и есть итератор. Иными словами, это объект, поддерживающий определённый набор операций.</p>
<p>Ключевые концепции</p>
<p>        Текущий указываемый элемент.</p>
<p>        Операция инкремента.</p>
<p>        Равенство.</p>
<p><strong>363. Что такое «начальный» итератор и «конечный» итератор? Какие методы, связанные с итераторами, обязательно включает каждый контейнер?</strong></p>
<p>Указывает на начало последовательности и на элемент сразу за конечным в последовательности.</p>
<p>begin, end</p>
<p><strong>364. Чем константный итератор отличается от неконстантного?</strong></p>
<p>Нельзя менять значение, доступное по итератору.</p>
<p><strong>365. Объясните, что такое «недействительный» итератор. В каких случаях итераторы становятся недействительными?</strong></p>
<p>Итератор не указывающий на элемент в контейнере или итератор за последним элементом.</p>
<p>В случае изменения размера контейнера.</p>
<p><strong>366. Какие категории итераторов вы знаете? Какие операции обязательно реализуются для всех категорий итераторов?</strong></p>
<p>Чтения, записи, однонаправленный, двунаправленные, произвольного доступа</p>
<p>        Текущий указываемый элемент.</p>
<p>        Операция инкремента.</p>
<p>        Равенство.</p>
<p><strong>367. К какому виду итераторов можно отнести встроенный указатель и почему?</strong></p>
<p>Произвольного доступа. Потому что реализует необходимый набор операций и эти операции выполняются за постоянное время.</p>
<p><strong>368. Какие вспомогательные функции для итераторов вы знаете? В каких случаях оправдано их применение?</strong></p>
<p>advance() distance()</p>
<p>чтобы выразить расстояние между элементами в контейнерах, где произвольный доступ выполняется за линейное время.</p>
<p>Оправдано на небольших контейнерах.</p>
<p><strong>369. Какие адаптеры итераторов реализованы в библиотеке?</strong></p>
<p>revesre iterators.</p>
<p><strong>370. Объясните, почему итераторы реализованы как вложенные классы в контейнерах.</strong></p>
<p>Чтобы определять последовательности, необходимо строго контролировать типы итераторов.</p>
<p><strong>371. Чем отличаются итераторы вставки от обычных итераторов?</strong></p>
<p>Позволяют избежать переполнения контейнеров, изменяя их размеры.</p>
<p><strong>372. Каким образом используются потоковые итераторы?</strong></p>
<p>Это итераторы однонаправленного доступа, которые образуют интерфейс для потока, как контейнера.</p>
<p><strong>373. Какие стандартные функторы реализованы в библиотеке STL? Каково их основное назначение?</strong></p>
<p>логические и арифметические операции</p>
<p>когда имеешь дело с числовыми или логическими классами</p>
<p><strong>374. Для чего нужны адаптеры функторов bind1st() и bind2nd()?</strong></p>
<p>вызывают бинарную функцию в качестве первого и второго аргументов соответственно</p>
<p><strong>375. Как применяются адаптеры-отрицатели?</strong></p>
<p>Возвращают противоположный предикат.</p>
<p><strong>376. Почему алгоритмы remove() не удаляют элементы из контейнеров? Как реально удалить элементы из контейнера?</strong></p>
<p>Потому что тогда изменится размер контейнера и сделает недействительными итераторы. Дорогая операция.</p>
<p>Необходимо явно его сжать и укоротить erase();</p>
<p><strong>377. Чем отличается стабильная сортировка от обычной?</strong></p>
<p>Не меняет местами одинаковые элементы. Гарантированная скорость в худших случаях.</p>
<p><strong>378. Какую функцию выполняет алгоритмы unique()?</strong></p>
<p>Удаляют соседние равные элементы сортированного контейнера.</p>
<p><strong>379. Могут ли стандартные алгоритмы работать со строками?</strong></p>
<p>Да.</p>
<p><strong>380. Нужно ли сортировать ассоциативные контейнеры?</strong></p>
<p>Нет.</p>
<p><strong>381. Можно ли алгоритмы для работы с множествами применять для последовательных контейнеров? При каких условиях?</strong></p>
<p>Можно только для сортированных последовательностей, иначе результат не будет подчиняться правилам работы с последовательностью.</p>
<p><strong>382. Какие алгоритмы предназначены для заполнения контейнера значениями? С какими контейнерами они могут работать?</strong></p>
<p>Модифицирующие</p>
<p>        transform</p>
<p>        fill</p>
<p>        generate</p>
<p>        replace</p>
<p>        reverse</p>
<p><strong>383. Каким образом заполнить с помощью алгоритма generate() последовательный контейнер, не имеющий ни одного элемента?</strong></p>
<p>Использовать inserter</p>
<p><strong>384. Перечислите алгоритмы, предназначенные для операций с каждым элементом контейнера.</strong></p>
<p>for_each</p>
<p>transform</p>
<p>copy</p>
<p>replace</p>
<p>fill</p>
<p><strong>385. Что обозначают аббревиатуры- vtbl, vptr</strong></p>
<p>таблица виртуальных функций. в gcc располагается в начале класса.</p>
<p><strong>386.</strong> Что такое виртуальный базовый класс.</p>
<p>        в тех случаях, когда необходимо предоставить общий базовый класс, необходимо использовать виртуальный базовый класс.</p>
<p><strong>387. Какое наследование по умолчанию в этих случаях</strong></p>
<p><strong>        </strong><strong>class XX: B{}</strong></p>
<p><strong>        struct YY: B{}</strong></p>
<p>закрытое</p>
<p>открытое</p>
<p><strong>388. когда необходим виртуальный деструктор?</strong></p>
<p>для полиморфных типов, чтобы знать, какой тип уничтожать.</p>
<p><strong>389. В каком порядке инициализируются глобальные переменные? переменные класса?</strong></p>
<p>порядок объявления в пределах единицы трансляции. в порядке объявления.</p>
<p><strong>390. Что такое спецификация шаблонов: полная и частичная</strong></p>
<p>Описание отличного от стандартного поведения при заданных частных случаях инстанцирования шаблона.</p>
<p><strong>391. Как выглядит инициализатор для структуры?</strong></p>
<p>Так же, как и для массива (и класс им можно инициализировать)</p>
<p><strong>392. Какие виды шаблонов могуть быть аргументами других шаблонов?</strong></p>
<p>только шаблоны классов</p>
]]></content:encoded>
			<wfw:commentRss>http://www.fulcrumweb.com.ua/archives/2000/feed</wfw:commentRss>
		<slash:comments>1</slash:comments>
		</item>
	</channel>
</rss>

