Stdafx h что это: c++ — Где взять stdafx.h в Visual Studio 2019?

c++ — Ошибка при использовании #include вместо #include

Вопрос задан 5 лет 2 месяца назад

Изменён 5 лет 1 месяц назад

Просмотрен 8k раза

В visual studio C++, при создании нового проекта, вместо #include <iostream> (как в примерах) стоит #include <stdafx.h>. Если его заменить на #include <iostream>, то получается ошибка компиляции.

Можно это как-то изменить?

• c++
• visual-studio

4

Это особенность Visual Studio, которая может ускорять сборку проекта. Начинающих только сбивает с толку. Рекомендую её просто отключить, только и всего. Тогда все будет работать как по учебнику.

Для этого зайдите в свойства проекта (правая кнопка по проекту в solution explorer, properties) и в Precompiled Headers отключите их как показано на рисунке:

4

Visual Studio использует #include <stdafx.h> для реализации предкомпилированных заголовков — то есть, для ускорения компиляции. #include <stdafx.h> должно быть первой существенной строкой файла (то есть, непустой и не комментарием).

Если вам нужно указать #include <iostream>, укажите его следующей строкой.

---

Я бы не рекомендовал отказываться от #include <stdafx.h> и предкомпилированных заголовков. Правильное использование предкомпилированных заголовков улучшает время компиляции, особенно в больших проектах.

1

Зарегистрируйтесь или войдите

Регистрация через Google

Регистрация через Facebook

Регистрация через почту

Отправить без регистрации

Почта

Необходима, но никому не показывается

Отправить без регистрации

Почта

Необходима, но никому не показывается

Нажимая на кнопку «Отправить ответ», вы соглашаетесь с нашими пользовательским соглашением, политикой конфиденциальности и политикой о куки

c++ — Стандарнтые заголовочные файлы внутри stdafx.

h

Вопрос задан 6 лет 3 месяца назад

Изменён 6 лет 3 месяца назад

Просмотрен 334 раза

Стоит ли включать в предкомпилированный заголовочный файл stdafx.h заголовочные файлы стандартной библиотеки (string, algorithm и т.п.), ведь они не изменяются?

Смущает то, что необходимо писать #include "stdafx.h" в каждом .cpp файле. Используется Visual Studio 2015.

• c++
• visual-studio-2015
• header

12

Если вы приняли решение использовать Precompiled Headers (для ускорения сборки), то заголовки стандартных библиотек

нужно включать в stdafx. h ведь для этого весь сыр-бор и затевается, чтобы их один раз компилятор распарсил, и далее для всех остальных файлов уже использовал приготовленные (прекомпилинные) файлы. Соответственно как раз не изменяемые файлы и надо включать в него, чтобы не вызывать лишний раз пересборки этих precompiled headers.

Механизм прекомпиленных заголовков довольно гибкий. Вы можете отключить его полностью, или для отдельных файлов. А также для одной группы файлов использовать один precompiled header, для другой группы другой. Ну и имя stdafx.h хоть и по дефолту, но не фиксированное, можете изменить на любое другое.

Если я правильно понял ваш вопрос, то я не советую включать заголовочные файлы внутрь заголовка <stdafx.h>.

Во-первых, это делает код менее читабельным, так как сеет сомнение у читающего ваш код, включили ли вы правильно все заголовки, или программа компилируется лишь из-за того, что в некоторой реализации стандартной библиотеки в стандартный заголовок был включен другой стандартный заголовок.

Во-вторых, такой код не будет переносим на платформы, где отсутствует заголовок <stdafx.h>. Если же не включать в него заголовочные файлы, то вам будет достаточно просто его закомментировать или удалить. То есть упрощается работа. И никто не будет спрашивать, а что это за заголовок.

12

Зарегистрируйтесь или войдите

Регистрация через Google

Регистрация через Facebook

Регистрация через почту

Отправить без регистрации

Почта

Необходима, но никому не показывается

Отправить без регистрации

Почта

Необходима, но никому не показывается

Нажимая на кнопку «Отправить ответ», вы соглашаетесь с нашими пользовательским соглашением, политикой конфиденциальности и политикой о куки

stdafx.

h

• Цель предварительных заголовков
• Как предварительно скомпилированные заголовки работают
• Как использовать предварительные заголовки
• Life Hack
• Что включать в stdafx.h
• заголовки
  • Неустранимая ошибка C1083: Не удается открыть предварительно скомпилированный файл заголовка: «Debug\project.pch»: Нет такого файла или каталога
  • Неустранимая ошибка C1010: неожиданный конец файла при поиске предварительно скомпилированного заголовка. Вы забыли добавить ‘#include «stdafx.h»‘ в исходный код?
  • Неустранимая ошибка C1853: предварительно скомпилированный заголовочный файл «project.pch» взят из предыдущей версии компилятора, или предварительно скомпилированный заголовок — это C++, и вы используете его из C (или наоборот)
  • Компилятор неправильно себя ведет при использовании предварительно скомпилированных заголовков
  • Весь проект продолжает полностью перекомпилироваться при использовании прекомпилированных заголовков
  • Происходит что-то странное
  • Проект, использующий прекомпилированные заголовки, не может быть проанализирован PVS-Studio
• Вывод

Эта статья предназначена для тех программистов, которые только начинают работать со средой Visual Studio и пытаются компилировать в ней свои проекты на C++. В незнакомой среде все может выглядеть странно и сложно, а новичков особенно раздражает файл stdafx.h, вызывающий странные ошибки при компиляции. Довольно часто все заканчивается тем, что они старательно отключают все предкомпилированные заголовки в каждом проекте. Мы написали эту статью, чтобы помочь новичкам в Visual Studio разобраться во всем этом.

Назначение предварительно скомпилированных заголовков

Предварительно скомпилированные заголовки предназначены для ускорения сборки проекта. Приступая к работе с Visual C++, программисты обычно пробуют его на очень небольших проектах, которые не могут показать прирост производительности от использования предварительно скомпилированных заголовков. И с ними, и без них программа компилируется одинаково. Это как раз то, что смущает пользователя; он не видит смысла в этой опции и делает вывод, что она нужна для каких-то конкретных задач и никогда ему не понадобится. Это заблуждение может длиться годами.

Предварительно скомпилированные заголовки на самом деле очень полезная технология. Выгоду можно увидеть даже с проектом всего из нескольких десятков файлов. Использование таких тяжелых библиотек в качестве буста сделает прирост производительности особенно заметным.

Если вы изучите файлы *.cpp в своем проекте, то заметите, что многие из них содержат одни и те же наборы заголовков, например , , . Эти заголовки, в свою очередь, включают в себя другие заголовки и так далее.

Все это приводит к тому, что препроцессор компилятора снова и снова выполняет одну и ту же работу — он должен много раз читать одни и те же файлы, вставлять их друг в друга, обрабатывать #ifdef и раскрывать макросы. Из-за этого одни и те же операции повторяются огромное количество раз.

Объем работы препроцессора во время компиляции проекта может быть значительно уменьшен. Идея состоит в том, чтобы предварительно обработать группу файлов, а затем просто вставить уже подготовленные текстовые фрагменты, где это необходимо.

На самом деле включает еще несколько шагов; вместо простого текста можно хранить более высокообработанную информацию. Я не знаю, как именно это все реализовано в Visual C++, но знаю, что, например, можно хранить уже разбитый на лексемы текст. Это еще больше ускорит процесс компиляции.

Как работают предварительно скомпилированные заголовки

Файл, содержащий предварительно скомпилированные заголовки, имеет расширение «.pch». Имя файла обычно совпадает с названием проекта, но вы, естественно, можете изменить это и любые другие используемые имена в настройках. Файл *.pch может быть довольно большим, что зависит от того, сколько заголовков в нем развернуто. В PVS-Studio, например, он занимает около 3 Мбайт.

Файл *.pch создается в результате компиляции файла stdafx.cpp. Этот файл создается с помощью переключателя «/Yc», который используется специально для указания компилятору создать предварительно скомпилированные заголовки. Файл stdafx.cpp может содержать одну строку: #include «stdafx.h».

Самое интересное хранится в файле «stdafx.h». В него должны быть включены все заголовочные файлы, которые необходимо предварительно скомпилировать. Например, ниже показан файл stdafx.h, который мы используем в PVS-Studio (текст сокращен для статьи):

 #include "VivaCore/VivaPortSupport.h"
//Для /Стены
#предупреждение прагмы (push)
# предупреждение прагмы (отключить: 4820)
# предупреждение прагмы (отключить: 4619)
# предупреждение прагмы (отключить: 4548)
# предупреждение прагмы (отключить: 4668)
# предупреждение прагмы (отключить: 4365)
# предупреждение прагмы (отключить: 4710)
# предупреждение прагмы (отключить: 4371)
# предупреждение прагмы (отключить: 4826)
# предупреждение прагмы (отключить: 4061)
# предупреждение прагмы (отключить: 4640)
#include 
  #include <строка>
#include <вектор>
#include <иопоток>
#include 
#include <алгоритм>
#include <набор>
#include <карта>
#include <список>
#include <дек>
#include <память>
#pragma warning(pop) //Для /Wall 

Директивы «#pragma warning» необходимы для избавления от предупреждений, генерируемых в стандартных библиотеках.

Теперь файл «stdafx.h» должен быть включен во все файлы *. c/*.cpp. Вы также должны удалить из этих файлов все заголовки, уже включенные в «stdafx.h».

Но что делать, если в разных файлах используются несколько похожие, но все же разные наборы заголовков? Например:

• Файл A: <вектор>, <строка>
• Файл B: <вектор>, <алгоритм>
• Файл C: <строка>, <алгоритм>

Следует ли создавать отдельные предварительно скомпилированные заголовки? Ну, вы можете сделать это, но вам не нужно.

Вам нужно создать только один предварительно скомпилированный заголовок, в котором будут развернуты <вектор>, <строка> и <алгоритм>. Выгода от того, что препроцессору не нужно читать ряд файлов и вставлять их друг в друга, перевешивает потери на синтаксическом анализе дополнительных фрагментов кода.

Как использовать предварительно скомпилированные заголовки

При запуске нового проекта мастер Visual Studio создает два файла: stdafx.h и stdafx.cpp. Именно через них реализуется механизм предкомпилированных заголовков.

Эти файлы могут иметь любые другие имена; важно не название, а параметры компиляции, которые вы указываете в настройках проекта.

Файл *.c/*.cpp может использовать только один предварительно скомпилированный заголовок. Однако один проект может содержать несколько разных предварительно скомпилированных заголовков. Предположим, что у нас есть только один на данный момент.

Итак, если вы воспользовались Мастером, файлы stdafx.h и stdafx.cpp уже созданы для вас, а также определены все необходимые параметры компиляции.

Если вы не использовали в своем проекте параметр предварительно скомпилированных заголовков, давайте узнаем, как его включить. Предлагаю следующий алгоритм:

• Включить предкомпилированные заголовки во всех конфигурациях для всех файлов *.cpp. Это можно сделать на вкладке «Предварительно скомпилированный заголовок»:
  • Установите значение «Использовать (/Yu)» для параметра «Предварительно скомпилированный заголовок».
  • Установите «stdafx. h» для параметра «Предварительно скомпилированный файл заголовка».
  • Установите «$(IntDir)$(TargetName).pch» для параметра «Предварительно скомпилированный выходной файл заголовка».
• Создайте файл stdafx.h и добавьте его в проект. Мы включим в этот файл те заголовки, которые мы хотим предварительно обработать.
• Создайте файл stdafx.cpp и добавьте его в проект. В этом файле всего одна строка: #include «stdafx.h».
• Изменить настройки файла stdafx.cpp во всех конфигурациях; установите значение «Создать (/ Yc)» для параметра «Предварительно скомпилированный заголовок».

Теперь мы включили опцию предварительно скомпилированных заголовков. Если мы запустим компиляцию сейчас, компилятор создаст файл *.pch. Однако компиляция завершится чуть позже из-за ошибок.

Мы настроили все файлы *.c/*.cpp для использования предварительно скомпилированных заголовков, но это только начало. Теперь нам нужно добавить #include «stdafx. h» в каждый файл.

Заголовок «stdafx.h» должен быть самым первым для включения в файл *.c/*.cpp. Это обязательно! В противном случае вы гарантированно получите ошибки компиляции.

Если подумать, это действительно имеет смысл. Когда файл «stdafx.h» включен в самом начале, вы можете подставить в файл уже предварительно обработанный текст. Этот текст остается неизменным все время и ни на что не влияет.

А теперь представьте, что мы включили какой-то другой файл до «stdafx.h», и этот файл содержит строку #define bool char. Это сделает ситуацию неопределенной, так как мы изменили содержимое всех файлов, где упоминается «bool». Теперь вы не можете просто вставить предварительно обработанный текст, так как весь механизм «прекомпилированных заголовков» ломается. Я считаю, что это одна из причин, почему «stdafx.h» должен быть включен в первую очередь. Возможно, есть и какие-то другие причины.

Лайфхак

Вводить вручную #include «stdafx. h» во все файлы *.c/*.cpp довольно утомительно и скучно. Кроме того, вы получите новую ревизию в системе контроля версий с большим количеством измененных файлов. Это бесполезно.

Сторонние библиотеки, включенные в проект в качестве исходных файлов, вызывают дополнительные проблемы. Изменение этих файлов не имеет смысла. Лучшим решением было бы отключить для них предкомпилированные заголовки, но это неудобно при использовании ряда небольших библиотек. Вы будете постоянно спотыкаться о предварительно скомпилированные заголовки.

Однако есть более простой способ обработки предварительно скомпилированных заголовков. Этот метод не является универсальным, но во многих случаях он мне помогал.

Вместо того, чтобы вручную добавлять #include «stdafx.h» во все файлы, вы можете использовать параметр «Принудительно включаемый файл».

Перейдите на вкладку «Дополнительно». Выберите все конфигурации. В поле «Forced Included File» напишите следующий текст:

 StdAfx. h;%(ForcedIncludeFiles) 

Отныне «stdafx.h» будет автоматически включаться в начало ВСЕХ компилируемых файлов. ВЫГОДА!

Вам больше не нужно вручную добавлять #include «stdafx.h» в начало каждого файла *.c/*.cpp — компилятор сделает это автоматически.

Что включить в stdafx.h

Очень важный вопрос. Бездумное включение каждого отдельного заголовка в «stdafx.h» замедлит процесс компиляции, а не ускорит его.

Все файлы, содержащие «stdafx.h», зависят от их содержимого. Предположим, что «stdafx.h» включает в себя файл «X.h». Небольшое изменение «X.h» может привести к полной перекомпиляции всего проекта.

Важное правило. Убедитесь, что ваш файл «stdafx.h» включает только те файлы, которые никогда или ОЧЕНЬ редко изменяются. Лучшими кандидатами являются заголовки из системных и сторонних библиотек.

Если вы включаете собственные файлы проектов в «stdafx.h», будьте особенно осторожны. Включайте только те файлы, которые изменяются очень-очень редко.

Если какие-либо файлы *.h изменяются раз в месяц, это слишком часто. В большинстве случаев для внесения всех необходимых правок в h-файл требуется более одного раза — обычно 2 или 3 раза. Полная перекомпиляция всего проекта 2 или 3 раза довольно неприятная вещь, не так ли? Кроме того, все ваши коллеги должны будут сделать то же самое.

Но не будьте слишком фанатичны в отношении неизменности файлов. Включайте только те заголовки, которые вы используете очень часто. Включение не имеет смысла, если вам нужно всего пару файлов. Вместо этого просто включите этот файл там, где это необходимо.

Несколько предкомпилированных заголовков

Для чего может понадобиться несколько предкомпилированных заголовков в одном проекте? Ну, это действительно довольно редкая ситуация. Но вот пара примеров.

Представьте, что в проекте одновременно используются файлы *.c и *.cpp. Использовать для них общий файл *.pch нельзя — компилятор выдаст ошибку.

Вам необходимо создать два файла *. pch. Один из них создается после компиляции C-файла (xx.c), другой — после компиляции C++-файла (yy.cpp). Соответственно, вы должны указать в настройках использовать один прекомпилированный заголовок для C-файлов, а другой для C++-файлов.

Примечание. Не забудьте задать разные имена для этих двух файлов *.pch. В противном случае они будут заменять друг друга.

Другая ситуация:

Одна часть проекта использует одну большую библиотеку, а другая часть использует другую большую библиотеку.

Естественно, разные части проекта не должны знать об обеих библиотеках: возможно (к несчастью) совпадение имен сущностей в разных библиотеках.

Логично создать два предварительно скомпилированных заголовка и использовать их в разных частях программы. Как мы уже упоминали, вы можете использовать любые имена для файлов, из которых создаются файлы *.pch. Ну и даже имя файла *.pch тоже можно поменять. Конечно, все это нужно делать очень аккуратно, но в использовании двух предварительно скомпилированных заголовков нет ничего особенно сложного.

Типичные ошибки при использовании предварительно скомпилированных заголовков

Теперь, когда вы внимательно прочитали текст выше, вы поймете и устраните все ошибки, связанные с stdafx.h. Но предлагаю еще раз быстро просмотреть типичные ошибки начинающих программистов и разобраться в их причинах. Практика делает совершенным.

Неустранимая ошибка C1083: Не удается открыть предварительно скомпилированный файл заголовка: «Debug\project.pch»: Нет такого файла или каталога

Вы пытаетесь скомпилировать файл, который использует предварительно скомпилированный заголовок, а соответствующий файл *.pch отсутствует. Возможные причины:

• Файл stdafx.cpp не скомпилирован, поэтому файл *.pch еще не создан. Это может произойти, например, когда вы сначала очищаете решение, а затем пытаетесь скомпилировать один файл *.cpp (Компилировать Ctrl-F7). Чтобы решить проблему, скомпилируйте все решение или хотя бы файл stdafx.cpp.
• В настройках не указан файл для генерации файла *. pch — то есть проблемы с ключом компиляции /Yc. Эта проблема характерна для новичков в Visual Studio, которые впервые пытаются использовать предварительно скомпилированные заголовки в своем проекте. Чтобы узнать, как это сделать правильно, см. выше раздел «Как использовать предварительно скомпилированные заголовки».

Неустранимая ошибка C1010: неожиданный конец файла при поиске предварительно скомпилированного заголовка. Вы забыли добавить ‘#include «stdafx.h»‘ в исходный код?

Текст ошибки говорит сам за себя, если вы его прочтете. Файл компилируется с ключом /Yu. Это означает, что должен использоваться предварительно скомпилированный заголовок, но в файле отсутствует «stdafx.h».

Вам необходимо добавить #include «stdafx.h» в файл.

Если вы не можете этого сделать, не используйте предварительно скомпилированный заголовок для этого файла *.c/*.cpp. Удалите ключ /Ю.

Неустранимая ошибка C1853: предварительно скомпилированный заголовочный файл ‘project.

pch’ взят из предыдущей версии компилятора, или предварительно скомпилированный заголовок — это C++, и вы используете его из C (или наоборот)

Проект содержит оба C (* .c) и C++ (*.cpp). Вы не можете использовать для них общий предварительно скомпилированный заголовок (файл *.pch).

Возможные решения:

• Отключить предварительно скомпилированные заголовки для всех C-файлов. Практика показывает, что файлы *.c препроцессируются в несколько раз быстрее, чем файлы *.cpp. Если у вас всего несколько файлов *.c, вы не потеряете в производительности, отключив для них предварительно скомпилированные заголовки.
• Создайте два предварительно скомпилированных заголовка. Первый должен быть сгенерирован из stdafx_cpp.cpp, stdafx_cpp.h; второй из stdafx_c.c, stdafx_c.h. Соответственно, вы должны использовать разные предварительно скомпилированные заголовки для файлов *.c и *.cpp. Имена файлов *.pch, разумеется, тоже должны быть разными.

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

Возможно, вы сделали что-то не так. Например, строка #include «stdafx.h» не первая в файле.

Взгляните на этот пример:

 int A = 10;
#include "stdafx.h"
int _tmain (int argc, _TCHAR * argv []) {
  вернуть А;
} 

Этот код не скомпилируется, компилятор выдает на первый взгляд странное сообщение об ошибке:

 error C2065: 'A' : необъявленный идентификатор 

Он считает, что весь текст перед #include «stdafx.h» (включая эту строку) является предварительно скомпилированным заголовком. При компиляции файла компилятор заменит текст перед #include «stdafx.h» текстом из файла *.pch. Это приведет к потере строки «int A = 10».

Правильный код должен выглядеть так:

 #include "stdafx.h"
интервал А = 10;
int _tmain (int argc, _TCHAR * argv []) {
  вернуть А;
} 

Еще один пример:

 #include "my.h"
#include "stdafx.h" 

Содержимое файла «my.h» использоваться не будет. В результате вы не сможете использовать функции, объявленные в этом файле. Такое поведение сильно смущает программистов. Они пытаются «вылечить» его, полностью отключив предварительно скомпилированные заголовки, а потом придумывают истории о том, насколько глючен Visual C++. Помните одну вещь: компилятор — это один из инструментов с наименьшим количеством ошибок. В 9В 9,99% случаев злиться надо не на компилятор, а на ошибки в собственном коде (Proof).

Чтобы избежать подобных проблем, ПОСТОЯННО добавляйте #include «stdafx.h» в самое начало файла. Ну, вы можете оставлять комментарии перед #include «stdafx.h»; они в любом случае не участвуют в компиляции.

Другой способ — использовать Forced Included File. Смотрите раздел «Лайфхак» выше.

Весь проект полностью перекомпилируется при использовании предварительно скомпилированных заголовков

Вы добавили в stdafx.h файл, который постоянно редактируете. Или вы могли включить автоматически сгенерированный файл по ошибке.

Внимательно изучите содержимое файла «stdafx.h»: он должен содержать только заголовки, которые никогда не изменяются или изменяются очень редко. Имейте в виду, что хотя некоторые включаемые файлы не изменяются сами по себе, они могут содержать ссылки на другие файлы *.h, которые изменяются.

Происходит что-то странное

Иногда вы можете столкнуться с проблемой, когда ошибка не исчезает даже после исправления кода. Отладчик сообщает что-то странное.

Эта проблема может быть связана с файлом *.pch. По какой-то причине компилятор не замечает, что один из заголовочных файлов был изменен, поэтому не перекомпилирует файл *.pch, а продолжает вставлять ранее сгенерированный текст. Это могло быть вызвано некоторыми ошибками, связанными со временем модификации файла.

Это ЧРЕЗВЫЧАЙНО редкая ситуация. Но это возможно, и вы должны знать об этом. Лично я сталкивался с этой проблемой всего 2 или 3 раза за многолетнюю карьеру. Это может быть решено путем полной перекомпиляции проекта.

Проект с предварительно скомпилированными заголовками не может быть проанализирован PVS-Studio

Это самая частая проблема, о которой пользователи сообщают в нашу службу поддержки. Подробнее см. в документации: «PVS-Studio: Устранение неполадок». Здесь я дам лишь краткое изложение проблемы.

Если решение компилируется хорошо, это не значит, что оно правильно реализовано. Одно решение часто может содержать несколько проектов, каждый из которых использует свои предварительно скомпилированные заголовки (то есть свои собственные файлы stdafx.h и stdafx.cpp).

Проблемы возникают, когда программисты начинают использовать файлы из одного проекта в другом. Это может быть удобно, и этот метод действительно довольно популярен. Но они также забывают, что файл *.cpp содержит строку #include «stdafx.h».

Вопрос, какой из файлов stdafx.h будет занят? Если программа компилируется хорошо, значит, программисту просто повезло.

К сожалению, нам очень сложно воспроизвести поведение при использовании файла *.pch. Видите ли, «честный» препроцессор работает совсем по-другому.

Вы можете проверить, реализовано ли ваше решение неправильно, временно отключив предварительно скомпилированные заголовки. Затем вы можете получить множество интересных ошибок, которые заставят вас искренне задаться вопросом, как ваш проект вообще мог скомпилироваться.

Подробности см. в документации. Если что-то осталось неясным, обратитесь в нашу службу поддержки.

Заключение

Как видите, работать с предварительно скомпилированными заголовками довольно просто. Программисты, которые пытаются их использовать и постоянно сталкиваются с «многочисленными ошибками компилятора», просто не понимают принципов работы этого механизма. Я надеюсь, что эта статья помогла вам преодолеть это недоразумение.

Предварительно скомпилированные заголовки — очень полезная опция, позволяющая значительно повысить скорость компиляции проекта.

#Cpp #Knowledge

Теги:

#Cpp#Knowledge

Раз в месяц мы можем отправлять вам по электронной почте подборку наших лучших статей

Предварительно скомпилированные заголовки | Ogre Wiki

Введение в учебник

В этом руководстве вы узнаете, как ускорить время компиляции приложения Ogre в Visual Studio, используя предварительно скомпилированные заголовки.

• В этом руководстве предполагается, что у вас есть знания в области программирования на C++ и вы можете настроить и скомпилировать приложение Ogre. Инструкции см. в разделе «Настройка приложения».

Содержание

• Предпосылки
• Введение
• Что такое предварительно скомпилированные заголовки?
• Как настроить предварительно скомпилированные заголовки
  • Создать stdafx.h
  • Создать stdafx.cpp
  • Включить stdafx.h в каждый файл вашего проекта
  • Настройте Visual Studio для использования предварительно скомпилированных заголовков
  • Настройка Visual Studio для создания предварительно скомпилированных заголовков
• Заключение

На современном компьютере создание простого приложения «hello world» для Ogre может занять несколько секунд. Даже если вы еще не добавили свой собственный код.
Это пустая трата времени

• прерывает ваш рабочий процесс
• затрудняет экспериментирование
• не нужен

Решение: используйте предварительно скомпилированные заголовки в Visual Studio.
На среднем портативном компьютере (WinXP, VC++2008 Express, Core2Duo 1,5 ГГц, 2 ГБ ОЗУ) время сборки Ogre Basic Tutorial 1 увеличивается с 20 секунд до 1 секунды с предварительно скомпилированными заголовками. Так это в 20 раз быстрее!

Мы не будем здесь объяснять, что такое предварительно скомпилированные заголовки, для этого в сети есть места получше.

Просто знайте, что предварительно скомпилированные заголовки наиболее полезны, когда в вашем проекте есть много больших включений для обработки. Это в случае с Огре. Вы указываете Visual Studio, какие включенные заголовки редко или никогда не изменяются, тогда Visual Studio предварительно скомпилирует их один раз, сохранит их в файле в папке вашего проекта с расширением файла .pch (угадайте, почему) и будет использовать это временное вывод каждый раз, когда вы компилируете свой проект.

Не будет выигрыша в скорости, когда заголовки предварительно компилируются, то есть когда вы впервые компилируете свой проект, или когда один из заголовков для предварительной компиляции был изменен (что редко или никогда не должно происходить), но после что, выигрыш вообще огромен.

Хорошо, если один из предварительно скомпилированных заголовков изменится, Visual Studio автоматически воссоздаст для вас файл .pch. Поэтому после настройки предварительно скомпилированные заголовки больше не будут мешать вам.

Настройка предварительно скомпилированных заголовков проста и занимает всего несколько шагов, особенно если вы только начинаете новый проект.

Создать stdafx.h

stdafx.h — это заголовочный файл, в который вы включаете все те заголовки, которые вам нужны в вашем проекте, которые редко или никогда не меняются. Это могут быть заголовки Ogre или что угодно еще. Имя этого заголовочного файла не имеет значения, но по соглашению мы называем его stdafx.h.

 // stdafx.h

// Заголовки Ogre, которые вам нужны
#include 
#include 
#include 
#include 
#include 
#include  h>
#include 
#include 
#include 

// любой другой заголовок может быть включен, как обычно
#if ОГР_ПЛАТФОРМ == ОГР_ПЛАТФОРМ_WIN32
# определить WIN32_LEAN_AND_MEAN
#include "windows.h"
#endif 

Создать stdafx.cpp

Затем вам понадобится связанный файл .cpp.
Создайте файл stdafx.cpp в своем проекте. Опять же, имя может быть любым, но всегда лучше следовать соглашениям.
В файл stdafx.cpp можно поместить все, что угодно, но единственным требованием является включение stdafx.h в качестве первого оператора.

 // stdafx.cpp
#include "stdafx.h"

// все, что вы хотите после этого 

Включите stdafx.h в каждый файл вашего проекта

Включить stdafx.h

• в качестве первого оператора
• во ВСЕХ ваших файлах .h и .cpp

В больших проектах с сотнями файлов используйте сценарии, например Python, чтобы убедиться, что это делается автоматически.

В Visual Studio вы можете сделать следующее (убедитесь, что вы выбрали «Все конфигурации»):

Свойства конфигурации -> C/C++ -> Дополнительно
Введите «stdafx.h» в поле «Принудительно включить файл»; это заставит компилятор Visual Studio вставлять заголовочный файл в начало каждого файла без необходимости включать его вручную.

Перейдите к настройкам проекта, убедитесь, что вы выбрали «Все конфигурации», затем перейдите к
Свойства конфигурации -> C/C++ -> Предварительно скомпилированные заголовки,
и выберите «Использовать предварительно скомпилированный заголовок».
Убедитесь, что stdafx.h является используемым заголовочным файлом, а для остальных оставьте значение по умолчанию.

Теперь Visual Studio попытается использовать предварительно скомпилированные заголовки при следующей сборке проекта. Но это не сработает, так как у нас еще нет предварительно скомпилированного заголовка (файла .pch). Итак, давайте скажем Visual Studio создать его для нас.