Как создать файл cpp в windows 10

C++ Documentation. Contribute to MicrosoftDocs/cpp-docs development by creating an account on GitHub.
description title ms.custom ms.date helpviewer_keywords ms.assetid

Learn more about: Walkthrough: Creating a Standard C++ Program (C++)

Walkthrough: Creating a Standard C++ Program (C++)

get-started-article

10/27/2021

command-line applications [C++], standard

standard applications [C++]

48217e35-d892-46b7-93e3-f6f0b7e2da35

Walkthrough: Creating a Standard C++ Program (C++)

You can use Visual Studio to create Standard C++ programs. By following the steps in this walkthrough, you can create a project, add a new file to the project, modify the file to add C++ code, and then compile and run the program by using Visual Studio.

You can type your own C++ program or use one of the sample programs. The sample program in this walkthrough is a console application. This application uses the set container in the C++ Standard Library.

[!NOTE]
If conformance with a specific version of the C++ language standard (for example, C++14, C++17, or C++20) is required, use the /std:c++14, /std:c++17, or /std:c++20 compiler option. (Visual Studio 2017 and later.)

Prerequisites

To complete this walkthrough, you must understand the fundamentals of the C++ language.

To create a project and add a source file

The following steps vary depending on which version of Visual Studio you are using. To see the documentation for your preferred version of Visual Studio, use the Version selector control. It’s found at the top of the table of contents on this page.

::: moniker range=»>=msvc-160″

To create a C++ project in Visual Studio

  1. From the main menu, choose File > New > Project to open the Create a New Project dialog box.

  2. At the top of the dialog, set Language to C++, set Platform to Windows, and set Project type to Console.

  3. From the filtered list of project types, choose Console App then choose Next. In the next page, enter a name for the project, and specify the project location if desired.

  4. Choose the Create button to create the project.

::: moniker-end

::: moniker range=»msvc-150″

To create a C++ project in Visual Studio 2017

  1. Create a project by pointing to New on the File menu, and then clicking Project.

  2. In the Visual C++ project types pane, click Windows Desktop, and then click Windows Console Application.

  3. Type a name for the project. By default, the solution that contains the project has the same name as the project, but you can type a different name. You can also type a different location for the project.

  4. Click OK to create the project.

::: moniker-end

::: moniker range=»msvc-140″

To create a C++ project in Visual Studio 2015

  1. Create a project by pointing to New on the File menu, and then clicking Project.

  2. In the Visual C++ project types pane, click Windows Desktop, and then click Windows Console Application.

  3. In the New Project dialog box, expand Installed > Templates > Visual C++, and then select Win32. In the center pane, select Win32 Console Application.

  4. Type a name for the project. By default, the solution that contains the project has the same name as the project, but you can type a different name. You can also type a different location for the project.

  5. Click OK to create the project.

  6. Complete the Win32 Application Wizard.

  7. Click Next, then make sure Console Application is selected and uncheck the Precompiled Headers box.

  8. Click Finish.

::: moniker-end

Add a new source file

  1. If Solution Explorer isn’t displayed, on the View menu, click Solution Explorer.

  2. Add a new source file to the project, as follows.

    1. In Solution Explorer, right-click the Source Files folder, point to Add, and then click New Item.

    2. In the Code node, click C++ File (.cpp), type a name for the file, and then click Add.

    The .cpp file appears in the Source Files folder in Solution Explorer, and the file is opened in the Visual Studio editor.

  3. In the file in the editor, type a valid C++ program that uses the C++ Standard Library, or copy one of the sample programs and paste it in the file.

  4. Save the file.

  5. On the Build menu, click Build Solution.

    The Output window displays information about the compilation progress, for example, the location of the build log and a message that indicates the build status.

  6. On the Debug menu, click Start without Debugging.

    If you used the sample program, a command window is displayed and shows whether certain integers are found in the set.

Next Steps

Previous: Console Applications in Visual C++
Next: Walkthrough: Compiling a Native C++ Program on the Command Line

See also

C++ Language Reference
C++ Standard Library

Источник
description title ms.custom ms.date helpviewer_keywords ms.assetid

Learn more about: Walkthrough: Creating a Standard C++ Program (C++)

Walkthrough: Creating a Standard C++ Program (C++)

get-started-article

10/27/2021

command-line applications [C++], standard

standard applications [C++]

48217e35-d892-46b7-93e3-f6f0b7e2da35

Walkthrough: Creating a Standard C++ Program (C++)

You can use Visual Studio to create Standard C++ programs. By following the steps in this walkthrough, you can create a project, add a new file to the project, modify the file to add C++ code, and then compile and run the program by using Visual Studio.

You can type your own C++ program or use one of the sample programs. The sample program in this walkthrough is a console application. This application uses the set container in the C++ Standard Library.

[!NOTE]
If conformance with a specific version of the C++ language standard (for example, C++14, C++17, or C++20) is required, use the /std:c++14, /std:c++17, or /std:c++20 compiler option. (Visual Studio 2017 and later.)

Prerequisites

To complete this walkthrough, you must understand the fundamentals of the C++ language.

To create a project and add a source file

The following steps vary depending on which version of Visual Studio you are using. To see the documentation for your preferred version of Visual Studio, use the Version selector control. It’s found at the top of the table of contents on this page.

::: moniker range=»>=msvc-160″

To create a C++ project in Visual Studio

  1. From the main menu, choose File > New > Project to open the Create a New Project dialog box.

  2. At the top of the dialog, set Language to C++, set Platform to Windows, and set Project type to Console.

  3. From the filtered list of project types, choose Console App then choose Next. In the next page, enter a name for the project, and specify the project location if desired.

  4. Choose the Create button to create the project.

::: moniker-end

::: moniker range=»msvc-150″

To create a C++ project in Visual Studio 2017

  1. Create a project by pointing to New on the File menu, and then clicking Project.

  2. In the Visual C++ project types pane, click Windows Desktop, and then click Windows Console Application.

  3. Type a name for the project. By default, the solution that contains the project has the same name as the project, but you can type a different name. You can also type a different location for the project.

  4. Click OK to create the project.

::: moniker-end

::: moniker range=»msvc-140″

To create a C++ project in Visual Studio 2015

  1. Create a project by pointing to New on the File menu, and then clicking Project.

  2. In the Visual C++ project types pane, click Windows Desktop, and then click Windows Console Application.

  3. In the New Project dialog box, expand Installed > Templates > Visual C++, and then select Win32. In the center pane, select Win32 Console Application.

  4. Type a name for the project. By default, the solution that contains the project has the same name as the project, but you can type a different name. You can also type a different location for the project.

  5. Click OK to create the project.

  6. Complete the Win32 Application Wizard.

  7. Click Next, then make sure Console Application is selected and uncheck the Precompiled Headers box.

  8. Click Finish.

::: moniker-end

Add a new source file

  1. If Solution Explorer isn’t displayed, on the View menu, click Solution Explorer.

  2. Add a new source file to the project, as follows.

    1. In Solution Explorer, right-click the Source Files folder, point to Add, and then click New Item.

    2. In the Code node, click C++ File (.cpp), type a name for the file, and then click Add.

    The .cpp file appears in the Source Files folder in Solution Explorer, and the file is opened in the Visual Studio editor.

  3. In the file in the editor, type a valid C++ program that uses the C++ Standard Library, or copy one of the sample programs and paste it in the file.

  4. Save the file.

  5. On the Build menu, click Build Solution.

    The Output window displays information about the compilation progress, for example, the location of the build log and a message that indicates the build status.

  6. On the Debug menu, click Start without Debugging.

    If you used the sample program, a command window is displayed and shows whether certain integers are found in the set.

Next Steps

Previous: Console Applications in Visual C++
Next: Walkthrough: Compiling a Native C++ Program on the Command Line

See also

C++ Language Reference
C++ Standard Library

Источник

0 / 0 / 0

Регистрация: 24.07.2010

Сообщений: 16

1

24.07.2010, 15:39. Показов 12843. Ответов 18

я недавно начал зучать язык программированя С++ и делаю это самостоятельно с помашю книг и интернета. я ищю статьи где было бы подробно описанно для каких функции какие файли создаються например для написания простого математического задания можно использовать файл .cpp, я так понимаю но у меня и с этим тоже проблемы, недавно я открыл «project», в ней файл .срр но когда я в этом же проекте создал второй .срр файл то после нажатия клавиш ctrl+F5 вывело ошибку
«Ошибка 1 error LNK2005: _main уже определен в sd.obj ars.obj arsen»
«Ошибка 3 fatal error LNK1169: обнаружен многократно определенный символ — один или более C:Documents and SettingsuserMy DocumentsVisual Studio 2008ProjectsarsenDebugarsen.exe 1 arsen
«

если кто то понял вчем дело буду очень признателень если даст мне совет.

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

если обяснение этого слишком длинна можете просто посоветовать ссылки где я могу найти ответы на вопросы такого рода.

заранее спасибо всем кто поможет

__________________
Помощь в написании контрольных, курсовых и дипломных работ, диссертаций здесь



0

159 / 156 / 47

Регистрация: 29.04.2009

Сообщений: 636

24.07.2010, 16:07

2

cpp может быть сколько угодно.У вас проблемы с функцией int main();
main Должна быть одна в ней запускается ваш код.



0

arsstyleh

0 / 0 / 0

Регистрация: 24.07.2010

Сообщений: 16

24.07.2010, 16:15

 [ТС]

3
C++ 
1
2
3
4
5
6
7
8
9
10
11
12

#include <iostream>
using namespace std;
 
int main()
{
    int var1;   //arajin popoxakan
    int var2;   //erkrord popoxakan
    var1 = 10;
    var2 = var1 + 10;
    cout << "var2 = var1 + 10 = " << var2 << endl;  // var2-i dursberum
    return 0;
}

если я написал такую программу и еще один файл добовляю а вней тоже есть

C++ 
1
2
3
4
5

#include <iostream>
using namespace std;
 
int main()
{..................}

то всегда выдаст эту ошибку? может я должен создать какой то файл где я напишу

C++ 
1
2
3
4
5

#include <iostream>
using namespace std;
 
int main()
{

ЭТУ ЧАСТЬ а в остальних срр файлах просто тело программы тоесть то что в кобках функции main
так будет правильно???

Извините если вопросы ОЧЕНЬ «ТУПЫЕ»



0

1551 / 917 / 193

Регистрация: 26.03.2010

Сообщений: 3,105

24.07.2010, 16:36

4

Вам же сказали, основная функция, она же main (), должна быть описана один раз.



1

Lonely_Romantic

8 / 8 / 2

Регистрация: 13.07.2010

Сообщений: 14

24.07.2010, 17:03

5

Не по теме:

Да нет, arsstyleh, не тупые :)

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

Ну если очень хочется, вот тебе пример, разбирайся.
Есть основной файл <Имя программы>.cpp:

C++ 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <iostream>
#include "MyMath.h"
 
using namespace std;
 
 
int _tmain(int argc, _TCHAR* argv[])
{
    int x,y,sum;
 
    cin >> x;
    cin >> y;
 
    sum = Summ(x,y);
    cout << sum << endl;
 
    system("PAUSE");
    return 0;
}

Подпрограмма Summ(x,y) вызывается в <Имя программы>.cpp, но она определена в MyMath.cpp
MyMath.h — это заголовочный файл для MyMath.cpp, в нем прототип функции описан.

MyMath.h:

C++ 
1
2
3
4
5
6
7
8

#include "stdafx.h"
 
#ifndef _math
#define _math
 
int Summ(int a,int b);
 
#endif

MyMath.cpp:

C++ 
1
2
3
4
5
6
7

#include "MyMath.h"
 
int Summ(int a,int b)
{   
    int r = a+b;
    return r;
}



2

0 / 0 / 0

Регистрация: 24.07.2010

Сообщений: 16

24.07.2010, 21:57

 [ТС]

6

Lonely_Romantic Спасибо, ваш ответ был понятливее…



0

Эксперт С++

2343 / 1716 / 148

Регистрация: 06.03.2009

Сообщений: 3,675

24.07.2010, 22:19

7

arsstyleh, изучайте литературу последовательно, тогда проблем не будет. Главное литературу правильно подобрать.



0

0 / 0 / 0

Регистрация: 24.07.2010

Сообщений: 16

24.07.2010, 22:30

 [ТС]

8

CyBOSSeR я вообщето искал литературу по этому принципу: чтобы было как можно больше страниц, потому что много книг изучал и пришел к выводу что чем больше страниц тем подробнее все написанно о программе. насшет «изучайте литературу последовательно» я с самого начала книги читаю и в полне внимательно, там просто не написанны подробности про то как создать файли как они должны быт распаложены, и если человек скажем создал один срр файл после чего захотел второй пример с книги написать в отдельном файле, там не сказанно что нужно создать файл и потом в каждом новом срр просто вызывать этот файл где написанно функция майн. (принцып как я понял такой же как и в php программировании где строятся например header, footer, потом при помощи include визываются эти файли.
А сейчась под рукой есть книга Х.М.Дейтел, П.Дж. Дейтел четвертое издание «как программировать на С++» и еше книга скачанная из сайта

 Комментарий модератора 
ссылки на подобные сайты запрещены. Правила форума п. 3.10

автор: Р. Лафоре «обьектно ориентированное программирование в С++» 4-е издание.

Если кто то может мне посоветовать литературу которую считает лучше чем эти, буду признателен.



0

102 / 102 / 23

Регистрация: 12.05.2010

Сообщений: 232

25.07.2010, 15:22

9

arsstyleh, Дейтла тебе пока что вполне хватит в ооп пока что не лезь, никуда не торопись, делай все последовательно, разбирай что делает каждая строчка… можешь почитать вот эти уроки по С/С++ там подробные примеры с комментариями



0

arsstyleh

0 / 0 / 0

Регистрация: 24.07.2010

Сообщений: 16

25.07.2010, 18:56

 [ТС]

10

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

C++ 
1
2
3
4
5
6

#include <iostream>
using ...
int main()
{
...
}

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



0

Эксперт JavaЭксперт С++

8377 / 3599 / 419

Регистрация: 03.07.2009

Сообщений: 10,708

25.07.2010, 19:22

11

arsstyleh, вы ошибаетесь. 2005 и 2008 одинаково не воспринимают функцию main в разных cpp файлах одного проекта. Другое дело, что то, о чем вы говорите, может быть тогда все остальные файлы должны были быть вручную выгружены из проекта и подключен только один cpp-файл с функцией main и выгруженные файлы попросту в таком случае не компилируются и не имеют никакого отношения к проекту



1

0 / 0 / 0

Регистрация: 24.07.2010

Сообщений: 16

25.07.2010, 19:47

 [ТС]

12

Цитата
Сообщение от arsstyleh
Посмотреть сообщение

просто тут не так как в 2005 версии, там можно было в одном проекте создовать несколько срр файлов

извините но помоему я тже имел ввиду что 2005 и 2008 версии отличаются. или все же не прав был????



0

Эксперт JavaЭксперт С++

8377 / 3599 / 419

Регистрация: 03.07.2009

Сообщений: 10,708

25.07.2010, 20:13

13

arsstyleh, я не писал что они отличаются, я написал вот что

Цитата
Сообщение от M128K145
Посмотреть сообщение

2005 и 2008 одинаково не воспринимают функцию main в разных cpp файлах одного проекта

2008 и 2005 относительно вашего вопроса абсолютно одинаковы.



1

102 / 102 / 23

Регистрация: 12.05.2010

Сообщений: 232

25.07.2010, 20:23

14

в принципе можно держать несколько файлов с функцией майн в одном проекте, это даже удобно для проверки разных частей программы. но активным должен быть только один файл с главной функцией. из компиляции можно исключать cpp и h файлы нажав на них правой кнопкой мышь — properties — general — excluded from build



1

Эксперт JavaЭксперт С++

8377 / 3599 / 419

Регистрация: 03.07.2009

Сообщений: 10,708

25.07.2010, 20:28

15

Mur3ik, это написано в 11 посте



1

Эксперт CАвтор FAQ

21264 / 8280 / 637

Регистрация: 30.03.2009

Сообщений: 22,635

Записей в блоге: 30

25.07.2010, 23:00

16

Господа, по-моему его интересует следующее. У человека есть проект в VS2008. Он хочет добавить к проекту ещё один файл *.cpp. Его интересует, куда в IDE надо нажать, чтобы добавить (потому как для IDE такое действие не совсем тривиально)

Ну и как-то надо доступно объяснить, что после создания нового файла вовсе не нужно туда копировать код main’а. И при нормельном создании нового файла проекта он (файл) должен быть пустым (т.е. не содержать никакого заранее сгенерённого текста)



1

0 / 0 / 0

Регистрация: 24.07.2010

Сообщений: 16

25.07.2010, 23:09

 [ТС]

17

Evg тебе спосибо за присоединение и всем за советы, кажется я не смог излогать понятнее то что мне интересовало, но уже нашел очень полезные материалы на сйте http://msdn.microsoft.com/ru-r… 35627.aspx



0

Модератор

Эксперт PythonЭксперт JavaЭксперт CЭксперт С++

11657 / 7170 / 1704

Регистрация: 25.07.2009

Сообщений: 13,137

26.07.2010, 03:23

18

Цитата
Сообщение от M128K145
Посмотреть сообщение

2008 и 2005 относительно вашего вопроса абсолютно одинаковы.

Мало того — ни один компилятор не скомпилирует вместе два файла, в которых определена функция с одним и тем же именем.



0

Эксперт CАвтор FAQ

21264 / 8280 / 637

Регистрация: 30.03.2009

Сообщений: 22,635

Записей в блоге: 30

26.07.2010, 11:11

19

Цитата
Сообщение от easybudda
Посмотреть сообщение

Мало того — ни один компилятор не скомпилирует вместе два файла, в которых определена функция с одним и тем же именем.

У него по ходу дела формировалась статическая библиотека. В юниксе, по крайней мере, такое точно бы прошло (просто ни один файл из библиотеки не попал бы в линковку, т.к. не снаружи не имеет нужных UNDEF’ов). Если под виндами принцип построения статической библиотеки такой же, том там тоже пройдёт



0
Источник

Среды разработки

Последнее обновление: 28.08.2017

Для создания программы на C++ нам нужны, как минимум, две вещи: текстовый редактор для набора кода и компилятор для превращения этого кода в приложение.
При этом для компиляции необходимо запускать консоль или терминал. Однако есть и более удобный способ — использование различных сред разработки или IDE.
Они, как правило, содержит встроенный текстовый редактор, компилятор и позволяют скомпилировать и запустить программу по одному клику мыши,
а также имеют еще множество разных вспомогательных возможностей.

Для программирования под Windows наиболее популярной средой разработки, если говорить о C++, является Visual Studio. Данную среду можно найти по ссылке
https://www.visualstudio.com/ru/vs/. Она доступна в ряде редакций. В частности,
можно использовать бесплатную и полнофункциональную версию Visual Studio 2017 Community.

После загрузки и запуска установщика Visual Studio в нем необходимо отметить пункт «Разработка классических приложений на C++»:

Установка С++ в Visual Studio 2017

Выбрав все необходимые пункты, нажмем ОК для запуска установки. После установки Visual Studio создадим первый проект. Для этого перейдем в меню
File (Файл) -> New (Создать) -> Project… (Проект), и нам откроется окно создания нового проекта. В нем перейдем в левой части окна к
языку С++ и выберем его подсекцию General:

Первый проект на Си в Visual Studio

В центральной части окна в качестве типа проекта выберем Empty Project, а внизу окна в поле для имени проекта дадим проекту имя HelloApp и нажмем на ОК для создания проекта.

После этого Visual Studio создаст пустой проект. Добавим в него текстовый файл для набора исходного кода. Для этого в окне Solution Explorer (Обозреватель решений)
нажмем правой кнопкой мыши на узел Source Files и в контекстом меню выберем Add -> New Item…:

Добавление файла на С++ в Visual Studio 2017

Затем нам откроется окно для добавления нового элемента:

Добавление исходного файла на C++ в Visual Studio 2017

Здесь нам надо выбрать пункт C++ File(.cpp), а внизу окна укажем для файла имя Hello.cpp. Как правило,
исходные файлы на C++ имеют расширение .сpp.

После добавления файла изменим опции проекта. Для этого перейдем к пункту меню Project -> Properties:

Свойства проекта С++ в Visual Studio

И в открывшемся окне свойств проекта в левой части перейдем к секции Linker ->System и далее для
поля SubSystem установим значение Console(/SUBSYSTEM:CONSOLE), выбрав нужный элемент в списке:

Closing console C++ in Visual Studio

Тем самым мы указываем, что мы хотим создать консольное приложение. После установки этого значения нажмем на кнопку «Применить», чтобы новые настройки конфигурации вступили в силу.

После добавления файла проект будет иметь следующую структуру:

Структура проекта на C++ в Visual Studio 2017

Вкратце пробежимся по этой структуре. Окно Solution Explorer содержит в решение. В данном случае оно называется HelloApp. Решение может содержать
несколько проектов. По умолчанию у нас один проект, который имеет то же имя — HelloApp. В проекте есть ряд узлов:

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

  • Header Files: предназначена для хранения заголовочных файлов с расширением .h

  • Resource Files: предназначена для хранения файлов ресурсов, например, изображений

  • Source Files: хранит файлы с исходным кодом

Теперь собственно создадим первую программу и определим в файле Hello.cpp простейший код, который будет выводить строку на консоль:

#include <iostream>        		// подключаем заголовочный файл iostream

int main()							// определяем функцию main
{									// начало функции
	std::cout << "Hello World!";	// выводим строку на консоль
	return 0;						// выходим из функции
}

Здесь использован весь тот код, который был рассмотрен в предыдущих темах про компиляцию с помощью g++.

Теперь запустим программу. Для этого в Visual Studio нажмем на сочетание клавиш Ctrl+F5 или выберем пункт меню Debug -> Start Without Debugging:

Запуск программы на C++ в Visual Studio

И в итоге Visual Studio передаст исходный код компилятору, который скомпилирует из кода исполняемый файл exe, который потом будет запущен на выполнение.
И мы увидим на запущенной консоли наше сообщение:

Первое приложение на языке программирования C++

После этого на жестком диске в проекте в папке Debug можно увидеть скомпилированный файл exe, который мы можем запускать независимо от Visual Studio:

Компиляция кода на языке программирования C++

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

  • HelloApp.ilk: файл «incremental linker», который используется компоновщиком для ускорения компоновки

  • HelloApp.pdb: файл, который содержит отладочную информацию

Источник

Время прочтения
16 мин

Просмотры 37K

Частенько нет необходимости запускать тяжеловесную IDE Visual Studio для компиляции небольших приложений, проведения каких-либо тестов кода, не требующего полномасштабной отладки. В подобных случаях можно оперативно собрать приложение в консольном режиме, используя возможности предоставляемые компилятором от Microsoft (cl.exe) и запускными модулями IDE (devenv.exe, msdev.exe). Далее приводится код файлов сценариев (cmd) интерпретатора командной строки Windows, который с небольшими изменениями каждый может настроить под себя, с учётом путей к Visual Studio в своей системе.

Компиляция cpp-файлов

Код сценария vc++_compile_and_link.cmd

:: --------------------------------------------------------------------------- ::
:: Перед использованием сценария рекомендуется задать системные переменные:    ::
:: sVSPath     - путь к корневому каталогу Visual C++,                         ::
:: sVSPathName - путь к основному исполнимому файлу Visual C++                 ::
:: (либо раскомментировать и отредактировать sVSPath, sVSPathName ниже в файле.::
:: --------------------------------------------------------------------------- ::
echo off
cls

echo -------------------------------------- 
echo ---------- .:: -=LEXX=- ::. ----------
echo -------------------------------------- 
echo ------ %date% [%time%] ------
echo -------------------------------------- 

:: -------------------------------------- ::
::     Имена исходников (через пробел)    ::
:: -------------------------------------- ::
set gavSrc=MySource1.cpp MySource2.cpp


:: -------------------------------------- ::
:: Дополнительно, если необходимо, для Qt ::
:: - заголовочный файл,содержащий Q_OBJECT::
:: из него будет сгенерирован moc_xxx.cpp ::
:: -------------------------------------- ::
::set gavSrcQtMoc=gavQtSignalSlot.h
set gavSrcQtMoc=""

:: -------------------------------------- ::
:: Версия компилятора:                    ::
::    6 - VC6,                            ::
::    8 - VC8 (2005),                     ::
::    9 - VC9,                            ::
::   10 - VC10 (2010)                     ::
::   11 - VC11 (2012)                     ::
:: -------------------------------------- ::
set iCompVer=11


:: -------------------------------------- ::
:: Режим компиляции:                      ::
::    0 - release,                        ::
::    1 - debug,                          ::
::    2 - генерирует прототипы функций    ::
::        (без компиляции)                ::
:: -------------------------------------- ::
set iModeComp=1

:: -------------------------------------- ::
::  Флаги наличия библиотеки:             ::
::      0 - нет, 1 - есть                 ::
:: -------------------------------------- ::
set bLibQt=0
set bLibCrt=0
set bLibBoost=0

:: -------------------------------------- ::
:: Режим линковки с Qt:                   ::
::    0 - shared (динамическая),          ::
::    1 - static (статическая)            ::
:: -------------------------------------- ::
set iModeQt=0

:: -------------------------------------- ::
:: Флаги специальных WINDDK               ::
::    0 - не используется                 ::
::    1 - WINDDK для Win2000, WinXP       ::
::        (в этом случае д.б. верно заданы::
::         gavIncPathDdkXP,gavLibPathDdkXP::
::         - см. ниже)                    ::
:: -------------------------------------- ::
set iWinddk=0

:: -------------------------------------- ::
::    Дополнительные флаги компилятора    ::
::   ( дефайны задавать так: -Dдефайн )   ::
:: -------------------------------------- ::
::set gavCompilFlags=-Dtest


:: -------------------------------------- ::
::     Подсистема приложения (одна из)    ::
:: -------------------------------------- ::
:: Win32 character-mode application: 
set gavSubsystem=CONSOLE
:: Application does not require a console:
::set gavSubsystem=WINDOWS
:: Device drivers for Windows NT:
::set gavSubsystem=NATIVE
:: Application that runs with the POSIX subsystem in Windows NT:
::set gavSubsystem=POSIX
:: Application that runs on a Windows CE device:
::set gavSubsystem=WINDOWSCE



:: -------------------------------------- ::
::          Пути к Visual Studio.         ::
::          !!! без кавычек !!!           ::
:: -------------------------------------- ::
:: VS6 (!! Путь к компилятору VS6 д.б. коротким и без пробелов - иначе ошибка линковки)
if %iCompVer%==6 set sVSPath=C:ProgsVC98
if %iCompVer%==6 set sVSPathName=%sVSPath%bincl.exe

:: VS8 
if %iCompVer%==8 set sVSPath=%SYSTEMDRIVE%Program FilesMicrosoft Visual Studio 8VC
if %iCompVer%==8 set sVSPathName=%sVSPath%bincl.exe

:: VS9
if %iCompVer%==9 set sVSPath=%SYSTEMDRIVE%Program FilesMicrosoft Visual Studio 9.0VC
if %iCompVer%==9 set sVSPathName=%sVSPath%bincl.exe

:: VS10
if %iCompVer%==10 set sVSPath=%SYSTEMDRIVE%Program FilesMicrosoft Visual Studio 10.0VC
if %iCompVer%==10 set sVSPathName=%sVSPath%bincl.exe
                   :: доп.пути для VS2010:
if %iCompVer%==10 set gavIncPathMy=%SYSTEMDRIVE%Program FilesMicrosoft SDKsWindowsv7.0AInclude
if %iCompVer%==10 set gavLibPathMy=%SYSTEMDRIVE%Program FilesMicrosoft SDKsWindowsv7.0ALib

:: VS11
if %iCompVer%==11 set sVSPath=%SYSTEMDRIVE%Program Files (x86)Microsoft Visual Studio 11.0VC
if %iCompVer%==11 set sVSPathName=%sVSPath%bincl.exe
                   :: доп.пути для VS2010:
if %iCompVer%==11 set gavIncPathMy=%SYSTEMDRIVE%Program Files (x86)Windows Kits8.0Includeum
if %iCompVer%==11 set gavIncPathMy2=%SYSTEMDRIVE%Program Files (x86)Windows Kits8.0IncludeShared
if %iCompVer%==11 set gavLibPathMy=%SYSTEMDRIVE%Program Files (x86)Windows Kits8.0IncludeLib
if %iCompVer%==11 set gavLibPathMy2=%SYSTEMDRIVE%Program Files (x86)Windows Kits8.0Libwin8umx86
::if %iCompVer%==11 set gavLibPathMy2=%SYSTEMDRIVE%Program Files (x86)Windows Kits8.0Libwin8umx64

echo Compilator version: VC%iCompVer%
echo Compilator path: %sVSPathName%

:: -------------------------------------- ::
::              Пути к Boost              ::
:: -------------------------------------- ::
set BOOST_ROOT=C:Progsboostboost_1_49_0


:: -------------------------------------- ::
::     Настройка путей к подключаемым     ::
::  файлам.   Каждый путь должен быть     ::
::         отдельной переменной !         ::
:: -------------------------------------- ::
set gavIncPathVS="%sVSPath%include"
set gavIncPathQt="%QTDIR%include"
set gavIncPathBoost="%BOOST_ROOT%"
set gavIncPathDdkCrt="C:ProgsWINDDK2600.1106inccrt"
set gavIncPathDdkXP="C:ProgsWINDDK2600.1106incw2k"

if not "%gavIncPathMy%"=="" (set gavIncPathAll=-I"%gavIncPathMy%" 
                             if not "%gavIncPathMy2%"=="" (
                                                           set gavIncPathAll=-I"%gavIncPathMy%" -I"%gavIncPathMy2%"
                                                          )
                            )
if %iWinddk%==1 (set gavIncPathAll=%gavIncPathAll% -I%gavIncPathDdkCrt% -I%gavIncPathDdkXP%)
if not %gavIncPathVS%=="" (set gavIncPathAll=%gavIncPathAll% -I%gavIncPathVS%)
if %bLibQt%==1 (if not %gavIncPathQt%=="" (set gavIncPathAll=%gavIncPathAll% -I%gavIncPathQt%))
if %bLibBoost%==1 (if not %gavIncPathBoost%=="" (set gavIncPathAll=%gavIncPathAll% -I%gavIncPathBoost%))
echo Include pathes: %gavIncPathAll%


:: -------------------------------------- ::
::  Настройка путей к библиотечным (.lib) ::
::  файлам.   Каждый путь должен быть     ::
::         отдельной переменной !         ::
:: -------------------------------------- ::
set gavLibPathDdkXP=C:ProgsWINDDK2600.1106libwxpi386
set gavLibPathVS=%sVSPath%lib

set gavLibPathAll=""
if %iWinddk%==1 (set gavLibPathAll=%gavLibPathAll% /LIBPATH:"%gavLibPathDdkXP%")
if not "%gavLibPathVS%"=="" (set gavLibPathAll=%gavLibPathAll% /LIBPATH:"%gavLibPathVS%")
if not "%gavLibPathMy%"=="" (set gavLibPathAll=%gavLibPathAll% /LIBPATH:"%gavLibPathMy%"
                             if not "%gavLibPathMy2%"=="" (
                                                           set gavLibPathAll=%gavLibPathAll% /LIBPATH:"%gavLibPathMy%" /LIBPATH:"%gavLibPathMy2%"
                                                          )
                            )

set gavLibPathBoost="%BOOST_ROOT%stagelib"
if %bLibBoost%==1 (if not %gavLibPathBoost%=="" (set gavLibPathAll=%gavLibPathAll% /LIBPATH:%gavLibPathBoost%))

set gavLibPathQtReleaseShared="%QTDIR%libreleaseshared"
set gavLibPathQtReleaseStatic="%QTDIR%libreleasestatic"
set gavLibPathQtDebugShared="%QTDIR%libdebugshared"
set gavLibPathQtDebugStatic="%QTDIR%libdebugstatic"
if %bLibQt%==1 (
                 if %iModeComp%==0 (
                                    if %iModeQt%==0 (
                                                     echo Qt mode: release shared
                                                     set gavLibPathAll=%gavLibPathAll% /LIBPATH:%gavLibPathQtReleaseShared%
                                                    )
                                    if %iModeQt%==1 (
                                                     echo Qt mode: release static
                                                     set gavLibPathAll=%gavLibPathAll% /LIBPATH:%gavLibPathQtReleaseStatic%
                                                    )
                                   )
                 if %iModeComp%==1 (
                                    if %iModeQt%==0 (
                                                     echo Qt mode: debug shared
                                                     set gavLibPathAll=%gavLibPathAll% /LIBPATH:%gavLibPathQtDebugShared%
                                                    )
                                    if %iModeQt%==1 (
                                                     echo Qt mode: debug static
                                                     set gavLibPathAll=%gavLibPathAll% /LIBPATH:%gavLibPathQtDebugStatic%
                                                    )
                                   )
               )
echo Lib pathes: %gavLibPathAll%

:: -------------------------------------- ::
::      Файлы библиотеки run-time.        ::
:: При необходимости добавить сюда нужные ::
:: -------------------------------------- ::
set gavLibFilesCrt=""
if %bLibCrt%==1 (set gavLibFilesCrt=user32.lib ole32.lib Gdi32.lib Ws2_32.lib Imm32.lib Comdlg32.lib Winspool.lib Advapi32.lib)
if not "%gavLibFilesCrt%"=="" (set gavLibFilesAll=%gavLibFilesCrt%)

:: -------------------------------------- ::
::         Файлы библиотеки Qt.           ::
:: -------------------------------------- ::
set gavLibFilesQtShared=qtmain.lib qt-mt333.lib
set gavLibFilesQtStatic=qtmain.lib qt-mt.lib

if %bLibQt%==1 (
                if %iModeQt%==0 (set gavLibFilesAll=%gavLibFilesAll% %gavLibFilesQtShared%)
                if %iModeQt%==1 (set gavLibFilesAll=%gavLibFilesAll% %gavLibFilesQtStatic%)
               )

echo Lib files: %gavLibFilesAll%


:: -------------------------------------- ::
::     Настройка режимов компиляции       ::
:: -------------------------------------- ::
if %iModeComp%==0 (
               set gavLinkMode=/RELEASE
               :: для DLL: set gavCompMode=/MD
               set gavCompMode=/MT
               set gavOptimize=/O2 /GA
              )

if %iModeComp%==1 (
               set gavLinkMode=/DEBUG
               :: для DLL: set gavCompMode=/MDd
               set gavCompMode=/MTd
               ::set gavOptimize=/Od /ZI
               set gavOptimize=/Od /Z7
              ) 

if %iModeComp%==2 (
               set gavLinkMode=
               set gavCompMode=
               set gavOptimize=/Zg
              ) 

if %bLibQt%==1 (if %iModeQt%==1 (set gavCompMode=/MDd))

:: -------------------------------------- ::
::    Настройка подсистемы приложения     ::
:: -------------------------------------- ::
if not %gavSubsystem%=="" (set gavLinkSubsys=/SUBSYSTEM:%gavSubsystem%)


:: -------------------------------------- ::
::         Настройка компилятора          ::
:: -------------------------------------- ::
if %bLibQt%==1 (
                if %iModeQt%==0 (set gavCompilFlags=%gavCompilFlags% -DQT_DLL)
               )

:: -------------------------------------- ::
::        Удаление старых файлов          ::
:: -------------------------------------- ::
set gavOldObj=%gavSrc:.cpp=.obj,%
set gavOldObj=%gavOldObj:.c=.obj,%
set gavOldAsm=%gavOldObj:.obj=.asm%
for /F "tokens=1" %%A in ("%gavSrc%") do (set gavMainName=%%A)
set gavMainName=%gavMainName:.cpp=%
set gavMainName=%gavMainName:.c=%
set gavDelExt= %gavMainName%.exe, %gavMainName%.pdb, %gavMainName%.ilk, %gavOldObj% %gavOldAsm% __vc++_%gavMainName%.log
echo. 
echo Deleting old files: %gavDelExt% ...
echo. 
del %gavDelExt%
echo. 
echo ------------------
echo Compiling start...
echo ------------------
echo. 

if %bLibQt%==1 (if not %gavSrcQtMoc%=="" (
echo ------------------
echo Mocing file... 
echo ------------------
echo on
%QTDIR%binmoc %gavSrcQtMoc% -o moc_%gavSrcQtMoc%.cpp
@echo off
set gavSrc=%gavSrc% moc_%gavSrcQtMoc%.cpp
))

echo on
"%sVSPathName%" /EHsc %gavIncPathAll% %gavCompilFlags% /Fa %gavSrc% %gavCompMode% %gavOptimize% /link %gavLinkSubsys% %gavLinkMode% %gavLibPathAll% %gavLibFilesAll%>"__vc++_%gavMainName%.log"

@echo off
echo. 
echo ------------------
echo Compiling end...
echo ------------------
echo. 
echo -------------------------------------- 
echo ------ %date% [%time%] ------
echo -------------------------------------- 
echo ---------- .:: -=LEXX=- ::. ----------
echo -------------------------------------- 
:: -------------------------------------- ::
pause

Основные параметры, которые следует

однократно

настроить в вышеприведённом сценарии:
1) в разделе «Пути к Visual Studio» необходимо задать пути к файлам различных версий Visual Studio (если у вас их установлено несколько):

  • sVSPath — путь к основному каталогу Visual Studio т.е. к корневому каталогу, в котором содержатся все прочие подкаталоги для данной версии VS.
  • gavIncPathMy — возможно для VS 11.0 потребуется задать свои пути к подключаемым заголовочным файлам.

2) в разделе «Пути к Boost» можно задать BOOST_ROOT — путь к коревому каталогу библиотеки Boost (если она у вас установлена).
3) в разделе «Настройка путей к подключаемым файлам» при необходимости можно задать пути к заголовочным файлам Qt, WinDDK.
4) в разделе «Настройка путей к библиотечным (.lib) файлам» задаются пути к файлам библиотек (в частности для WinDDK).

Реже может возникнуть необходимость настроить следующие параметры под конкретный проект:
iCompVer — версия используемого компилятора (6 — для VC6, 8 — VC8 (2005), 9 — VC9, 10 — VC10 (2010), 11 — VC11 (2012).
gavLibFilesQtShared — имена .lib-файлов для динамически подключаемой библиотеки Qt;
gavLibFilesQtStatic — имена .lib-файлов для статически линкуемой библиотеки Qt.
gavLibFilesCrt — имена .lib-файлов для стандартных динамических библиотек, используемых в Windows.
iModeQt — режим линковки библиотеки Qt.
gavCompMode — флаги режима компиляции (однопоточные, многопоточные и т.п.).
gavOptimize — флаги оптимизации кода компилятором.

Чаще всего приходится менять параметры:
gavSrc — имена файлов с исходным кодом, разделённые пробелом (если их несколько).
bLibQt — флаг (0/1) необходимости использовать библиотеку Qt при сборке приложения.
bLibCrt — флаг (0/1) необходимости использовать стандартные CRT-библиотеки Windows при сборке приложения.
bLibBoost — флаг (0/1) необходимости использовать библиотеку Boost при сборке приложения.
gavSubsystem — подсистема создаваемого приложения: CONSOLE — консольное, WINDOWS — с графическим интерфейсом.

Результат (ошибки, сообщения) компиляции можно просмотреть в файле __vc++_XXX.log, где XXX — имя основного исходного файла

Сборка cpp-приложения из файлов проектов

Аналогично без запуска IDE можно собрать проект, используя файлы проектов и воркспейсов (dsp, dsw).

Код сценария vc++_dsp_dsw_compile.cmd

:: Перед использованием сценария рекомендуется задать системную переменную sVSPathName,
:: указывающую путь к основному исполнимому файлу Visual Studio либо раскомментировать 
:: и отредактировать sVSPathName ниже в этом файле...
@echo off
cls

echo -------------------------------------- 
echo ---------- .:: -=LEXX=- ::. ----------
echo -------------------------------------- 
echo ------ %date% [%time%] ------
echo -------------------------------------- 
:: -------------------------------------- ::
:: имя файла проекта (dsp) или вокспейса (dsw):
set sPrjFile=MyWorkspace.dsp

:: -------------------------------------- ::
:: Режим компиляции: 0 - release, 1 - debug, 2 - release и debug:
set iMode=2

:: -------------------------------------- ::
:: Режим обработки файлов: 
::        0 - удаление промежуточных файлов, 
::        1 - перекомпиляция изменившихся фйлов,
::        2 - полная пересборка проекта (рекомендуется при iMode=2)
set iSubMode=2


:: -------------------------------------- ::
:: Имя конфигурации:
if %sPrjFile:.dsp=% == %sPrjFile% (
   set sPrjName=%sPrjFile:.dsw=%
  ) ELSE (
   set sPrjName=%sPrjFile:.dsp=%
  )

:: Имя конфигурации - для режима release: 
set sConfigNameRelease="%sPrjName% - Win32 Release"
:: Имя конфигурации - для режима debug: 
set sConfigNameDebug="%sPrjName% - Win32 Debug"


:: -------------------------------------- ::
:: пути к Visual Studio:
:: set sVSPathName=%SYSTEMDRIVE%Program FilesMicrosoft Visual Studio 6.0CommonMSDev98BinMSDEV.EXE
:: set sVSPathName=%SYSTEMDRIVE%Program FilesMicrosoft Visual Studio 8Common7IDEVCExpress.exe
:: set sVSPathName=%SYSTEMDRIVE%Program FilesMicrosoft Visual Studio 9.0Common7IDEdevenv.exe

:: -------------------------------------- ::
:: Подрежим:

if %iSubMode%==0 (
               set iCompMode=/CLEAN
              )

if %iSubMode%==1 (
               set iCompMode=
              ) 

if %iSubMode%==2 (
               set iCompMode=/REBUILD
              ) 

:: -------------------------------------- ::
echo. 
echo ---------------------------------
echo [%sPrjName%]: compiling start...
echo ---------------------------------
echo. 
@echo off

if %iMode%==0 (
:: режим release: 
echo [%sPrjName%]: configuration mode:
echo     %sConfigNameRelease%
echo on
"%sVSPathName%" %sPrjFile% /MAKE %sConfigNameRelease% %iCompMode% /OUT __vc++_compile_release.log
)

@echo off
if %iMode%==1 (
:: режим debug: 
echo [%sPrjName%]: configuration mode:
echo     %sConfigNameDebug%
echo on
"%sVSPathName%" %sPrjFile% /MAKE %sConfigNameDebug% %iCompMode% /OUT __vc++_compile_debug.log
)
 
@echo off
if %iMode%==2 (
:: режим release и debug: 
echo [%sPrjName%]: configuration modes: 
echo     %sConfigNameRelease%
echo     %sConfigNameDebug%
echo on
"%sVSPathName%" %sPrjFile% /MAKE %sConfigNameRelease% %iCompMode% /OUT __vc++_compile_release.log
"%sVSPathName%" %sPrjFile% /MAKE %sConfigNameDebug%   %iCompMode% /OUT __vc++_compile_debug.log
)


@echo off
echo. 
echo ---------------------------------
echo [%sPrjName%]: compiling end.
echo ---------------------------------
echo. 
echo -------------------------------------- 
echo ------ %date% [%time%] ------
echo -------------------------------------- 
echo ---------- .:: -=LEXX=- ::. ----------
echo -------------------------------------- 
:: -------------------------------------- ::
pause

Компиляция cs-файлов

Вышерассмотренный функционал реализуем и для C#:

Код сценария vc#_compile_and_link.cmd

:: --------------------------------------------------------------------------- ::
:: Перед использованием сценария рекомендуется задать системные переменные:    ::
:: sVSPath     - путь к корневому каталогу Visual C#,                          ::
:: sVSPathName - путь к основному исполнимому файлу Visual C#                  ::
:: (либо отредактировать sVSPath, sVSPathName ниже в файле.::
:: --------------------------------------------------------------------------- ::
echo off
cls

echo -------------------------------------- 
echo ---------- .:: -=LEXX=- ::. ----------
echo -------------------------------------- 
echo ------ %date% [%time%] ------
echo -------------------------------------- 

:: -------------------------------------- ::
::     Имена исходников (через пробел)    ::
:: -------------------------------------- ::
set gavSrc=Program.cs


:: -------------------------------------- ::
:: Режим компиляции:                      ::
::    0 - release,                        ::
::    1 - debug,                          ::
:: -------------------------------------- ::
set iModeComp=1

:: -------------------------------------- ::
::     Подсистема приложения (одна из)    ::
:: -------------------------------------- ::
:: /target:exe                    Построить консольный исполняемый файл (по умолчанию) (Краткая форма: /t:exe)
set gavSubsystem=exe
:: /target:winexe                 Построить исполняемый файл Windows  (Краткая форма: /t:winexe)
::set gavSubsystem=winexe
:: /target:library                Построить библиотеку (Краткая форма: /t:library)
::set gavSubsystem=library
:: /target:module                 Построение модуля, который может быть добавлен в другую сборку (Краткая форма: /t:module)
::set gavSubsystem=module
:: /target:appcontainerexe        Построение исполняемого файла Appcontainer (Краткая форма: /t:appcontainerexe)
::set gavSubsystem=appcontainerexe
:: /target:winmdobj               Построение промежуточного файла среды выполнения Windows, используемого WinMDExp (Краткая форма: /t:winmdobj)
::set gavSubsystem=winmdobj

:: -------------------------------------- ::
::      ПЛАТФОРМА приложения (одна из)    ::                                  
::    (x86, Itanium, x64, arm или anycpu. ::
::      Платформа по умолчанию: anycpu.)  ::
:: -------------------------------------- ::
set gavPlatform=anycpu

:: -------------------------------------- ::
::    Дополнительные флаги компилятора    ::
:: -------------------------------------- ::
::set gavCompilFlags=

:: -------------------------------------- ::
::          Пути к Visual Studio.         ::
::          !!! без кавычек !!!           ::
:: -------------------------------------- ::
 set sVSPath=%WINDIR%Microsoft.NETFrameworkv4.0.30319
 set sVSPathName=%sVSPath%csc.exe

:: -------------------------------------- ::
::     Настройка путей к подключаемым     ::
::  файлам.   Каждый путь должен быть     ::
::         отдельной переменной !         ::
:: -------------------------------------- ::
set gavIncPathVS="%sVSPath%"

if not "%gavIncPathMy%"=="" (set gavIncPathAll=-I"%gavIncPathMy%")
if not %gavIncPathVS%=="" (set gavIncPathAll=%gavIncPathAll% -I%gavIncPathVS%)
echo Include pathes: %gavIncPathAll%


:: -------------------------------------- ::
::  Настройка путей к библиотечным (.lib) ::
::  файлам.   Каждый путь должен быть     ::
::         отдельной переменной !         ::
:: -------------------------------------- ::
set gavLibPathVS=%sVSPath%
if not "%gavLibPathVS%"=="" (set gavLibPathAll=/lib:"%gavLibPathVS%")
if not "%gavLibPathMy%"=="" (set gavLibPathAll=%gavLibPathAll% /lib:"%gavLibPathMy%")

echo Lib pathes: %gavLibPathAll%

:: -------------------------------------- ::
::      Файлы библиотеки run-time.        ::
:: При необходимости добавить сюда нужные ::
:: -------------------------------------- ::
:: set gavLibFilesCrt=user32.lib ole32.lib Gdi32.lib Ws2_32.lib Imm32.lib Comdlg32.lib Winspool.lib Advapi32.lib
::set gavLibFilesCrt=""
if not "%gavLibFilesCrt%"=="" (set gavLibFilesAll=%gavLibFilesCrt%)

echo Lib files: %gavLibFilesAll%


:: -------------------------------------- ::
::     Настройка режимов компиляции       ::
:: -------------------------------------- ::
if %iModeComp%==0 (
               set gavCompilFlags=%gavCompilFlags% /D:_RELEASE 
               set gavCompMode=/debug-
               set gavOptimize=/optimize+
              )

if %iModeComp%==1 (
               set gavCompilFlags=%gavCompilFlags% /D:_DEBUG 
               set gavCompMode=/debug+
               set gavOptimize=/optimize-
              ) 

:: -------------------------------------- ::
::    Настройка подсистемы приложения     ::
:: -------------------------------------- ::
if not %gavSubsystem%=="" (set gavLinkSubsys=/t:%gavSubsystem%)


:: -------------------------------------- ::
set gavDelExt=*.obj, *.exe, *.log, *.pdb
echo. 
echo Deleting old files: %gavDelExt% ...
echo. 
del %gavDelExt%
echo. 
echo ------------------
echo Compiling start...
echo ------------------
echo. 

echo on
"%sVSPathName%" %gavDefine% %gavCompilFlags% %gavCompMode% %gavOptimize% %gavLinkSubsys% /utf8output /fullpaths /platform:%gavPlatform% %gavLibPathAll% %gavLibFilesAll% %gavSrc%>__vc#_compile.log

@echo off
echo. 
echo ------------------
echo Compiling end...
echo ------------------
echo. 
echo -------------------------------------- 
echo ------ %date% [%time%] ------
echo -------------------------------------- 
echo ---------- .:: -=LEXX=- ::. ----------
echo -------------------------------------- 
:: -------------------------------------- ::
pause

Сборка cs-приложения из файлов солюшенов (sln) и проектов (csproj)

Код сценария vc#_sln_csproj_compile.cmd

:: Перед использованием сценария рекомендуется задать системную переменную sVSPathName,
:: указывающую путь к основному исполнимому файлу Visual Studio либо раскомментировать 
:: и отредактировать sVSPathName ниже в этом файле...
@echo off
cls

echo -------------------------------------- 
echo ---------- .:: -=LEXX=- ::. ----------
echo -------------------------------------- 
echo ------ %date% [%time%] ------
echo -------------------------------------- 
:: -------------------------------------- ::
:: имя файла проекта (.csproj) или вокспейса (sln):
set sPrjFile=MyProject.csproj

:: -------------------------------------- ::
:: Режим компиляции: 0 - release, 1 - debug, 2 - release и debug:
set iMode=2

:: -------------------------------------- ::
:: Режим обработки файлов: 
::        0 - удаление промежуточных файлов, 
::        1 - перекомпиляция изменившихся фйлов,
::        2 - полная пересборка проекта (рекомендуется при iMode=2)
set iSubMode=2


:: -------------------------------------- ::
:: Имя конфигурации:
if %sPrjFile:.sln=% == %sPrjFile% (
   set sPrjName=%sPrjFile:.sln=%
  ) ELSE (
   set sPrjName=%sPrjFile:.csproj=%
  )

:: Имя конфигурации - для режима release: 
:: set sConfigNameRelease="Release|Win32"
set sConfigNameRelease="Release"
:: Имя конфигурации - для режима debug: 
:: set sConfigNameDebug="Debug|Win32"
set sConfigNameDebug="Debug"


:: -------------------------------------- ::
:: пути к Visual Studio:
set sVSPathName=%SYSTEMDRIVE%Program Files (x86)Microsoft Visual Studio11.0Common7IDEdevenv.exe
:: set sVSPathName=%SYSTEMDRIVE%Program FilesMicrosoft Visual Studio 8Common7IDEVCExpress.exe
:: set sVSPathName=%SYSTEMDRIVE%Program FilesMicrosoft Visual Studio 9.0Common7IDEdevenv.exe

:: -------------------------------------- ::
:: Подрежим:

if %iSubMode%==0 (
               set iCompMode=/Clean
              )

if %iSubMode%==1 (
               set iCompMode=
              ) 

if %iSubMode%==2 (
               set iCompMode=/Rebuild
              ) 

:: -------------------------------------- ::
echo. 
echo ---------------------------------
echo [%sPrjName%]: compiling start...
echo ---------------------------------
echo. 
@echo off

if %iMode%==0 (
:: режим release: 
echo [%sPrjName%]: configuration mode:
echo     %sConfigNameRelease%
echo on
"%sVSPathName%" %sPrjFile% /Build %sConfigNameRelease% /Out __vc#_compile_release.log
)

@echo off
if %iMode%==1 (
:: режим debug: 
echo [%sPrjName%]: configuration mode:
echo     %sConfigNameDebug%
echo on
"%sVSPathName%" %sPrjFile% /Build %sConfigNameDebug%   /Out __vc#_compile_debug.log
)
 
@echo off
if %iMode%==2 (
:: режим release и debug: 
echo [%sPrjName%]: configuration modes: 
echo     %sConfigNameRelease%
echo     %sConfigNameDebug%
echo on
"%sVSPathName%" %sPrjFile% /Build %sConfigNameRelease% /Out __vc#_compile_release.log
"%sVSPathName%" %sPrjFile% /Build %sConfigNameDebug%   /Out __vc#_compile_debug.log
Rem /project lxDbLib.csproj /projectconfig Debug 
)


@echo off
echo. 
echo ---------------------------------
echo [%sPrjName%]: compiling end.
echo ---------------------------------
echo. 
echo -------------------------------------- 
echo ------ %date% [%time%] ------
echo -------------------------------------- 
echo ---------- .:: -=LEXX=- ::. ----------
echo -------------------------------------- 
:: -------------------------------------- ::
pause

На первый взгляд громоздкость данного кода, компенсируется простотой последующей работы в консоли. Всем приятного программирования!!!

Источник

Добавлено 27 марта 2021 в 11:09

Прежде чем мы сможем написать нашу первую программу, нам нужно научиться создавать новые программы в нашей интегрированной среде разработки (IDE). В этом уроке мы расскажем, как это сделать, а вы скомпилируете и запустите свою первую программу!

Проекты

Чтобы написать программу на C++ внутри IDE, мы обычно начинаем с создания нового проекта (мы покажем вам, как это сделать чуть позже). Проект – это контейнер, в котором хранятся все файлы исходного кода, изображения, файлы данных и т.д., которые необходимы для создания исполняемого файла (или библиотеки, веб-сайта и т.д.), который вы сможете запускать или использовать. Проект также сохраняет различные настройки IDE, компилятора и компоновщика, а также запоминает, где вы остановились, чтобы позже, при повторном открытии проекта состояние IDE можно было восстановить с того места, где вы остановились. Когда вы решите скомпилировать свою программу, все файлы .cpp в проекте будут скомпилированы и слинкованы.

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

Лучшая практика

Создавайте новый проект для каждой новой программы, которую вы пишете.

Консольные проекты

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

Ниже показан скриншот консоли Windows:

Рисунок 1 Консоль Windows

Рисунок 1 – Консоль Windows

По умолчанию консольные приложения не имеют графического пользовательского интерфейса (GUI), они выводят текст на консоль, считывают ввод с клавиатуры и компилируются в автономные исполняемые файлы. Они идеально подходят для изучения C++, поскольку сводят сложность к минимуму и обеспечивают работу в самых разных системах.

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

Рабочие пространства / решения

Когда вы создаете новый проект для своей программы, многие IDE автоматически добавляют ваш проект в «рабочее пространство» («workspace» или «solution») (термин зависит от IDE). Рабочее пространство – это контейнер, который может содержать один или несколько связанных проектов. Например, если вы пишете игру и хотите иметь отдельные исполняемые файлы для одиночной и многопользовательской игры, вам нужно будет создать два проекта. Обоим этим проектам не имело бы смысла быть полностью независимыми – в конце концов, они являются частью одной игры. Скорее всего, каждый из них будет настроен как отдельный проект в рамках одного рабочего пространства.

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

Написание вашей первой программы

Традиционно у программистов, пишущих на новом языке, первой программой является печально известная программа hello world, и мы не собираемся лишать вас этого опыта! Вы нас потом поблагодарите. Может быть.

Создание проекта в Visual Studio 2019

Когда вы запустите Visual Studio 2019, вы должны увидеть диалоговое окно, которое выглядит следующим образом:

Рисунок 2 Диалоговое окно Начало работы Visual Studio 2019

Рисунок 2 – Диалоговое окно «Начало работы» Visual Studio 2019

Выберите Создание проекта (Create a new project).

После этого вы увидите диалоговое окно, которое выглядит следующим образом:

Рисунок 3 Visual Studio 2019: диалоговое окно создания нового проекта

Рисунок 3 – Visual Studio 2019: диалоговое окно создания нового проекта

Если вы уже открыли предыдущий проект, вы можете открыть это диалоговое окно через меню Файл (File) → Создать (New) → Проект (Project).

Выберите Мастер классических приложений Windows (Windows Desktop Wizard) и нажмите Далее (Next). Если вы этого не видите, то вы, вероятно, при установке Visual Studio забыли выбрать установку Desktop development with C++. В этом случае вернитесь к уроку «0.6 – Установка интегрированной среды разработки (IDE)» и переустановите Visual Studio, как было показано (примечание: вместо полной переустановки вы можете запустить установщик Visual Studio и изменить существующую установку, чтобы добавить поддержку C++).

Далее вы увидите диалоговое окно, которое выглядит следующим образом:

Рисунок 4 Диалоговое окно настройки нового проекта Visual Studio 2019

Рисунок 4 – Диалоговое окно настройки нового проекта Visual Studio 2019

Замените существующее имя проекта на HelloWorld.

Рекомендуется также установить флажок «Поместить решение и проект в одном каталоге» (Place solution and project in the same directory), поскольку это сокращает количество подкаталогов, создаваемых с каждым проектом.

Нажмите Создать (Create), чтобы продолжить.

Наконец, вы увидите последнее диалоговое окно:

Рисунок 5 Диалоговое окно параметров проекта Visual Studio 2019

Рисунок 5 – Диалоговое окно параметров проекта Visual Studio 2019

Убедитесь, что тип приложения установлен как Консольное приложение (.exe) (Console Application (.exe)), и что параметр Предкомпилированный заголовок (Precompiled Header) не выбран. Затем нажмите ОК.

Вы создали проект! Чтобы продолжить, перейдите в раздел Обозреватель решений Visual Studio ниже.

Создание проекта в Visual Studio 2017 или в более ранней версии

Чтобы создать новый проект в Visual Studio 2017 или более ранней версии, выберите меню Файл (File) → Создать (New) → Проект (Project). Появится диалоговое окно, которое выглядит примерно так:

Рисунок 6 Диалоговое окно Новый проект Visual Studio 2017

Рисунок 6 – Диалоговое окно «Новый проект Visual Studio 2017»

Сначала убедитесь, что слева указан Visual C++. Если вы не видите Visual C++, возможно, вы забыли выбрать установку поддержку Desktop development with C++ при установке Visual Studio. В этом случае вернитесь к уроку «0.6 – Установка интегрированной среды разработки (IDE)» и переустановите Visual Studio, как было показано (примечание: вместо полной переустановки вы можете запустить установщик Visual Studio и изменить существующую установку, чтобы добавить поддержку C++).

Если вы используете Visual Studio 2017 v15.3 или новее, под Visual C++ выберите Windows Desktop, а затем выберите Windows Desktop Wizard в главном окне.

Если вы не видите вариант с Windows Desktop, возможно, вы используете старую версию Visual Studio. Отлично. Вместо этого выберите Win32, а затем Win32 Console Application в главном окне.

Внизу в поле Name введите название своей программы (замените существующее имя на HelloWorld). В поле Location вы можете при желании выбрать другое место для размещения вашего проекта. Пока подойдет и значение по умолчанию.

Нажмите ОК. Если вы используете старую версию Visual Studio, запустится мастер приложений Win32. Нажмите Next.

На этом этапе вы должны увидеть диалоговое окно мастера, которое выглядит примерно так (более старые версии Visual Studio используют другой стиль, но имеют большинство из тех же параметров):

Рисунок 7 Мастер создания десктопного приложения Visual Studio 2017

Рисунок 7 – Мастер создания десктопного приложения Visual Studio 2017

Убедитесь, что вы сняли флажок Предкомпилированный заголовок (Precompiled Header).

Затем нажмите ОК или Finish. Теперь ваш проект создан!

Обозреватель решений Visual Studio

В левой или правой части окна вы должны увидеть окно под названием Обозреватель решений. В этом окне Visual Studio создала для вас решение (решение «HelloWorld»). Внутри него, имя которого выделено жирным шрифтом, находится ваш новый проект (HelloWorld). Visual Studio создала для вас в этом проекте ряд файлов, в том числе HelloWorld.cpp (в элементе дерева Исходные файлы (Source Files)). Вы также можете увидеть некоторые другие файлы .cpp или .h, которые пока можете игнорировать.

Рисунок 8 Начальные окна Visual Studio 2019

Рисунок 8 – Начальные окна Visual Studio 2019

В текстовом редакторе вы увидите, что Visual Studio уже открыла HelloWorld.cpp и создала для вас код. Выделите и удалите весь код и введите/скопируйте следующий код в вашу IDE:

#include <iostream>
 
int main()
{
	std::cout << "Hello, world!";
	return 0;
}

Чтобы скомпилировать программу, либо нажмите F7 (если это не сработает, попробуйте Ctrl + Shift + B), либо перейдите в меню Сборка (Build) → Собрать решение (Build Solution). Если всё пойдет хорошо, вы должны увидеть следующее в окне вывода:

Сборка начата…
1>------ Сборка начата: проект: HelloWorld, Конфигурация: Debug Win32 ------
1>HelloWorld.cpp
1>HelloWorld.vcxproj -> C:UsersusersourcereposHelloWorldDebugHelloWorld.exe
========== Сборка: успешно: 1, с ошибками: 0, без изменений: 0, пропущено: 0 ==========

Или, в зависимости от выбранного языка:

1>------ Build started: Project: HelloWorld, Configuration: Debug Win32 ------
1>HelloWorld.cpp
1>HelloWorld.vcxproj -> c:usersuserdocumentsvisual studio 2017ProjectsHelloWorldDebugHelloWorld.exe
========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ==========

Это означает, что ваша компиляция прошла успешно!

Вопрос: У меня вылетела ошибка C1010 («fatal error C1010: unexpected end of file while looking for precompiled header. Did you forget to add ‘#include «stdafx.h»‘ to your source?»). Что теперь?

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

Чтобы запустить скомпилированную программу, нажмите Ctrl + F5 или перейдите в меню Отладка (Debug) и выберите Запуск без отладки (Start Without Debugging). Вы увидите следующее:

Рисунок 9 Запуск программы

Рисунок 9 – Запуск программы

Это результат выполнения вашей программы! Поздравляем, вы скомпилировали и запустили свою первую программу!

Создание проекта в Code::Blocks

Чтобы создать новый проект, перейдите в меню File (Файл) → New (Новый) → Project (Проект). Появится диалоговое окно, которое выглядит следующим образом:

Рисунок 10 Code::Blocks. Диалоговое окно создания проекта

Рисунок 10 – Code::Blocks. Диалоговое окно создания проекта

Выберите Console application (консольное приложение) и нажмите кнопку Go (перейти/создать).

Если вы видите диалоговое окно мастера консольного приложения, нажмите Next (далее), убедитесь, что выбран C++, и снова нажмите Next.

Теперь вам будет предложено назвать ваш проект. Назовите проект HelloWorld. Вы можете сохранить его где угодно. В Windows мы рекомендуем сохранить его в подкаталоге диска C, например C:CBProjects.

Рисунок 11 Code::Blocks. Диалогове окно сохранения проекта

Рисунок 11 – Code::Blocks. Диалогове окно сохранения проекта

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

Теперь ваш новый проект создан.

В левой части экрана вы должны увидеть окно Management (управление) с выбранной вкладкой Projects (проекты). Внутри этого окна вы увидите папку Workspace с вашим проектом HelloWorld внутри:

Рисунок 12 Code::Blocks. Workspace

Рисунок 12 – Code::Blocks. Workspace

Внутри проекта HelloWorld разверните папку Sources (исходники) и дважды щелкните на «main.cpp». Вы увидите, что для вас уже написана программа hello world!

Замените ее следующим кодом:

#include <iostream>
 
int main()
{
	std::cout << "Hello, world!";
	return 0;
}

Чтобы собрать проект, нажмите Ctrl + F9 или перейдите в меню Build (Сборка) → Build (Сборка). Если всё пойдет хорошо, вы должны увидеть следующее в окне журнала сборки:

-------------- Build: Debug in HelloWorld (compiler: GNU GCC Compiler)---------------
mingw32-g++.exe -Wall -fexceptions -g -std=c++14  -c C:CBProjectsHelloWorldmain.cpp -o objDebugmain.o
mingw32-g++.exe  -o binDebugHelloWorld.exe objDebugmain.o   
Output file is binDebugHelloWorld.exe with size 1.51 MB
Process terminated with status 0 (0 minute(s), 0 second(s))
0 error(s), 0 warning(s) (0 minute(s), 0 second(s))

Это означает, что компиляция прошла успешно!

Чтобы запустить скомпилированную программу, нажмите Ctrl + F10 или перейдите в меню Build (Сборка) → Run (Запуск). Вы увидите что-то похожее на следующий скриншот:

Рисунок 13 Запуск программы

Рисунок 13 – Запуск программы

Это результат выполнения вашей программы!

Для пользователей Linux

Пользователям Linux до компиляции в Code::Blocks может потребоваться установить дополнительные пакеты. Дополнительные сведения смотрите в инструкциях по установке Code::Blocks в уроке «0.6 – Интегрированная среда разработки (IDE)».

Если вы используете g++ из командной строки

В этом случае создавать проект не нужно. Просто вставьте следующий код в текстовый файл с именем HelloWorld.cpp и сохраните файл:

#include <iostream>
 
int main()
{
	std::cout << "Hello, world!";
	return 0;
}

В командной строке введите:

g++ -o HelloWorld HelloWorld.cpp

Это скомпилирует и слинкует HelloWorld.cpp. Чтобы запустить скомпилированную программу, введите:

HelloWorld

или, возможно,

./HelloWorld

И вы увидите результат выполнения своей программы.

Если вы используете другие IDE или веб-компилятор

Вам нужно будет самостоятельно выяснить, как сделать следующее:

  1. создать консольный проект (только для IDE);
  2. добавить в проект файл .cpp (только для IDE, если он для вас не был создан автоматически);
  3. вставить в файл следующий код: 
    #include <iostream>
 
int main()
{
	std::cout << "Hello, world!";
	return 0;
}
  4. скомпилировать проект;
  5. запустить проект.

Если компиляция завершилась ошибкой

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

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

Во-вторых, посмотрите вопросы и ответы в уроке «0.8 – Несколько распространенных проблем C++», поскольку ваша проблема может быть там освещена.

В-третьих, прочтите комментарии ниже – кто-то мог столкнуться с той же проблемой.

Наконец, если всё вышеперечисленное не помогло, попробуйте поискать сообщение об ошибке в Google. Скорее всего, кто-то уже сталкивался с этим раньше и придумал, как это исправить.

Если ваша программа запускается, но окно мигает и сразу закрывается

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

Если это так с вашей IDE, следующие два шага решат вашу проблему:

Сначала добавьте или убедитесь, что следующие строки находятся в верхней части вашей программы (пользователи Visual Studio должны убедиться, что эти строки появляются после #include "pch.h" или #include "stdafx.h", если таковые существуют):

#include <iostream>
#include <limits>

Во-вторых, добавьте следующий код в конец функции main() (непосредственно перед оператором return):

// сбрасываем все флаги ошибок
std::cin.clear();
// игнорируем любые символы во входном буфере, пока не найдем новую строку
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), 'n');
// получаем от пользователя еще один символ
std::cin.get();

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

Другие решения, такие как обычно предлагаемое system("pause"), могут работать только в определенных операционных системах, и их следует избегать.

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

Для пользователей Visual Studio

Visual Studio не будет в конце делать паузу в работе консольного приложения, если оно запускается с отладкой (меню Отладка (Debug) → Начать отладку (Start Debugging)). Если вы хотите, чтобы она сделала паузу, вы можете либо использовать приведенное выше решение с дополнительным кодом, либо запустить свою программу без отладки (меню Отладка (Debug) → Начать отладку (Start Without Debugging)).

Заключение

Поздравляем, вы прошли самую сложную часть этого руководства (установку IDE и компиляцию вашей первой программы)!

Не волнуйтесь, если не понимаете, что делают все строки в программе HelloWorld. Мы рассмотрим и подробно объясним каждую строку в начале следующей главы.

Теги

C++ / CppCode::BlocksIDELearnCppVisual StudioДля начинающихОбучениеПрограммирование

Источник

Содержание

  1. Скомпилируйте и запустите программу на C в Linux и Windows
  2. Вступление
  3. Установите, скомпилируйте и выполните программу на языке C с помощью Visual C ++ 2008 Express Edition с пакетом обновления 1 в Windows
  4. Загрузить и установить
  5. Напишите, скомпилируйте и выполните свою первую программу
  6. Установить, скомпилировать и выполнить программу на C с Turbo C ++ в Windows
  7. Получить и установить
  8. Запустите Turbo C ++ на весь экран в Windows 7
  9. Написать, скомпилировать и запустить C программу
  10. Писать, компилировать и запускать программу на C, используя wxDev-C ++ в Windows
  11. Установить, скомпилировать и запустить C программу в Linux
  12. Список компиляторов C
  13. Процесс компиляции программ на C++
  14. Цель данной статьи:
  15. Состав компилятора g++
  16. Зачем нужно компилировать исходные файлы?
  17. Этапы компиляции:
  18. 1) Препроцессинг
  19. 2) Компиляция
  20. 3) Ассемблирование
  21. 4) Компоновка
  22. 5) Загрузка
  23. Заключение
  24. Пошаговое руководство. Компиляция программы на языке C из командной строки
  25. Предварительные требования
  26. Открытие командной строки разработчика в Visual Studio 2022
  27. Открытие командной строки разработчика в Visual Studio 2019
  28. Открытие командной строки разработчика в Visual Studio 2017
  29. Открытие командной строки разработчика в Visual Studio 2015
  30. Создание файла исходного кода на языке C и его компиляция из командной строки
  31. Следующие шаги
  32. Пошаговое руководство. Компиляция собственной программы на языке C++ из командной строки
  33. Предварительные требования
  34. Открытие командной строки разработчика
  35. Создание файла исходного кода на языке Visual C++ и его компиляция из командной строки
  36. Следующие шаги

Скомпилируйте и запустите программу на C в Linux и Windows

Вступление

В этом документе мы увидим, как мы можем скомпилировать и выполнить программу на C в Linux и Windows. Документ также содержит список доступных компиляторов Си.

Содержание:

Установите, скомпилируйте и выполните программу на языке C с помощью Visual C ++ 2008 Express Edition с пакетом обновления 1 в Windows

Загрузить и установить

Для загрузки укажите в браузере http://www.microsoft.com/visualstudio/en-us/products/2008-editions/express и выберите «Язык» и нажмите «Скачать бесплатно». После завершения загрузки запустите исполняемый файл, он попросит вас выбрать, хотите ли вы установить некоторые другие дополнительные продукты, снимите флажки с этих параметров, чтобы можно было установить только необходимый продукт. Процесс установки начнет загружать другие файлы с сайта Microsoft, и, в зависимости от скорости вашего соединения, установка займет некоторое время.

visual c++ 208 express edition

После завершения установки в Windows 7 запустите командную строку Visual Studio 2008 в меню «Все программы»> «Microsoft Visual C ++ 2008 Express Edition»> «Инструменты Visual Studio»> «Командная строка Visual Studio 2008».

visual studio command prompt

Напишите, скомпилируйте и выполните свою первую программу

Шаг 1: введите notepad demo.c (вы можете заменить имя файла своим собственным) и нажмите Enter, когда вас спросят, хотите ли вы создать новый файл, скажите «да».

visual studio command prompt prompt

Шаг 2: введите следующий код и нажмите Файл> Сохранить. Когда вас спросят, где сохранить файл, выберите подходящее место.

Шаг 3: Введите cl sample.c и нажмите ввод. Это скомпилирует программу для создания исполняемого файла (.exe).

compile

Шаг 4: Теперь просто введите имя образца файла и введите. Это покажет вам результат.

output

Установить, скомпилировать и выполнить программу на C с Turbo C ++ в Windows

Получить и установить

Запустите Turbo C ++ на весь экран в Windows 7

turbo c++ window

Написать, скомпилировать и запустить C программу

Откройте новый файл из меню «Файл»> «Создать» в Turbo C ++ IDE. Напишите небольшую программу в IDE.

Нажмите на Опции и перейдите в Каталоги. Нажмите «Каталоги» и установите «Выходной каталог», как вам нужно, и «Исходный каталог», где вы сохранили файл программы «Си».

Теперь перейдите к компиляции и нажмите на Компиляция. А затем нажмите на Run. Вы увидите вывод вашей программы на Си.

Писать, компилировать и запускать программу на C, используя wxDev-C ++ в Windows

После загрузки установщика запустите exe-файл, дважды щелкнув по нему, и мастер установки поможет вам выполнить установку. После завершения установки вы запускаете ее из «Программы», и при первом запуске она занимает некоторое время для разбора заголовочных файлов. Окно IDe выглядит следующим образом:

c1

Вы можете начать программирование, нажав Файл> Создать> Исходный файл в окне. Обратите внимание, что при сохранении файла вы должны выбрать тип файла как C, так как эта IDE также поддерживает C ++.

c2

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

c3

Когда компиляция завершена, она открывает новое окно, чтобы показать вам вывод.

c6
Если у вас есть ошибки, он показывает вас на панели ниже, как показано ниже.

c7

Хотя мы немного устарели, мы находим wxDev-C ++ отличной IDE для программирования C. Вы можете попробовать его, если используете Windows.

Установить, скомпилировать и запустить C программу в Linux

c install

Если компилятор C уже установлен, он покажет вам сообщение, как указано выше. Если нет, то будут установлены все необходимые пакеты.

Теперь откройте текстовый редактор и напишите небольшую программу на C, например, следующую и сохраните ее как demo.c:

Теперь выполните команду, как показано ниже, чтобы скомпилировать и выполнить файл:

c program run

Вот как вы можете установить GNU Gcc компилятор, написать программу на C и запустить ее под Linux.

Список компиляторов C

В следующей таблице приведен список доступных компиляторов Си. Это не полный список, но он даст вам четкое представление о различных компиляторах C, о том, какую ОС / платформу они поддерживают, и имеет ли она среду программирования.

Предыдущий: C учебник
Далее: C Basic

Источник

Процесс компиляции программ на C++

Цель данной статьи:

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

Все действия будут производиться на Ubuntu версии 16.04.
Используя компилятор g++ версии:

Состав компилятора g++

Мы не будем вызывать данные компоненты напрямую, так как для того, чтобы работать с C++ кодом, требуются дополнительные библиотеки, позволив все необходимые подгрузки делать основному компоненту компилятора — g++.

Зачем нужно компилировать исходные файлы?

Исходный C++ файл — это всего лишь код, но его невозможно запустить как программу или использовать как библиотеку. Поэтому каждый исходный файл требуется скомпилировать в исполняемый файл, динамическую или статическую библиотеки (данные библиотеки будут рассмотрены в следующей статье).

Этапы компиляции:

driver.cpp:

1) Препроцессинг

Самая первая стадия компиляции программы.

Препроцессор — это макро процессор, который преобразовывает вашу программу для дальнейшего компилирования. На данной стадии происходит происходит работа с препроцессорными директивами. Например, препроцессор добавляет хэдеры в код (#include), убирает комментирования, заменяет макросы (#define) их значениями, выбирает нужные куски кода в соответствии с условиями #if, #ifdef и #ifndef.

Хэдеры, включенные в программу с помощью директивы #include, рекурсивно проходят стадию препроцессинга и включаются в выпускаемый файл. Однако, каждый хэдер может быть открыт во время препроцессинга несколько раз, поэтому, обычно, используются специальные препроцессорные директивы, предохраняющие от циклической зависимости.

Получим препроцессированный код в выходной файл driver.ii (прошедшие через стадию препроцессинга C++ файлы имеют расширение .ii), используя флаг -E, который сообщает компилятору, что компилировать (об этом далее) файл не нужно, а только провести его препроцессинг:

Взглянув на тело функции main в новом сгенерированном файле, можно заметить, что макрос RETURN был заменен:

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

2) Компиляция

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

Ассемблерный код — это доступное для понимания человеком представление машинного кода.

Используя флаг -S, который сообщает компилятору остановиться после стадии компиляции, получим ассемблерный код в выходном файле driver.s:

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

3) Ассемблирование

Так как x86 процессоры исполняют команды на бинарном коде, необходимо перевести ассемблерный код в машинный с помощью ассемблера.

Ассемблер преобразовывает ассемблерный код в машинный код, сохраняя его в объектном файле.

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

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

Получим машинный код с помощью ассемблера (as) в выходной объектный файл driver.o:

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

4) Компоновка

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

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

Получим исполняемый файл driver:

5) Загрузка

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

Запустим нашу программу:

Заключение

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

Источник

Пошаговое руководство. Компиляция программы на языке C из командной строки

В состав Visual C++ включен компилятор языка C, позволяющий создавать как простые консольные программы, так и классические приложения Windows, мобильные приложения и многое другое.

В этом пошаговом руководстве показано, как создать простейшую программу на языке C в стиле «Hello, World» в текстовом редакторе с последующей компиляцией из командной строки. Если вы предпочитаете работать с C++ в командной строке, см. статью Пошаговое руководство. Компиляция собственной программы на языке C++ из командной строки. Если вы хотите попробовать интегрированную среду разработки Visual Studio вместо командной строки, см. статью Пошаговое руководство. Работа с проектами и решениями (C++) или Использование интегрированной среды разработки Visual Studio для разработки приложений для настольных систем на языке C++.

Предварительные требования

Для выполнения этого пошагового руководства необходимо установить Visual Studio и дополнительные компоненты Visual C++ или Build Tools для Visual Studio.

Visual Studio — это эффективная интегрированная среда разработки, которая поддерживает полнофункциональный редактор, диспетчеры ресурсов, отладчики и компиляторы для многих языков и платформ. Сведения об этих компонентах, а также о скачивании и установке Visual Studio, включая бесплатный выпуск Visual Studio Community, см. в этой статье.

При использовании версии Build Tools для Visual Studio устанавливаются только программы командной строки, библиотеки и компиляторы, необходимые для сборки программ на C и C++. Это идеальный вариант для создания заданий и упражнений, а установка выполняется относительно быстро. Чтобы установить только набор программ командной строки, скачайте Build Tools для Visual Studio на странице скачивания Visual Studio, а затем запустите установщик. В установщике Visual Studio выберите рабочую нагрузку Средства сборки C++ и щелкните Установить.

Прежде чем можно будет выполнить сборку программы C или C++ в командной строке, необходимо убедиться в том, что эти средства установлены и к ним можно получить доступ из командной строки. Visual C++ имеет сложные требования к среде командной строки для поиска используемых средств, заголовков и библиотек. Visual C++ нельзя использовать в простом окне командной строки без предварительной подготовки. Вам понадобится окно командной строки разработчика, являющееся обычным окном командной строки, в котором заданы все необходимые переменные среды. К счастью, Visual C++ устанавливает ярлыки для запуска командной строки разработчика, для которой настроена среда для сборок из командной строки. К сожалению, имена ярлыков командной строки разработчика и места их расположения отличаются практически во всех версиях Visual C++ и в различных версиях Windows. Первая задача пошагового руководства — найти нужный ярлык.

Ярлык командной строки разработчика автоматически задает правильные пути для компилятора и средств, а также для всех необходимых заголовков и библиотек. Некоторые из этих значений различаются для каждой конфигурации сборки. Если вы не используете ни один из ярлыков, эти значения среды необходимо задать самостоятельно. Дополнительные сведения см. в статье Использование набора инструментов MSVC из командной строки. Так как настраивать среду разработки сложно, настоятельно рекомендуется использовать ярлык командной строки разработчика вместо создания собственного.

Инструкции отличаются в зависимости от используемой версии Visual Studio. Чтобы ознакомиться с документацией по предпочтительной версии Visual Studio, используйте селектор Версия. Он находится в верхней части оглавления на этой странице.

Открытие командной строки разработчика в Visual Studio 2022

Если вы установили Visual Studio 2022 в Windows 10 или более поздней версии, откройте меню «Пуск» и выберите Все приложения. Прокрутите вниз и откройте папку Visual Studio 2022 (не приложение Visual Studio 2022). Выберите элемент Командная строка разработчика для VS 2022, чтобы открыть окно командной строки.

Открытие командной строки разработчика в Visual Studio 2019

Если вы установили Visual Studio 2019 в Windows 10 или более поздней версии, откройте меню «Пуск» и выберите Все приложения. Прокрутите вниз и откройте папку Visual Studio 2019 (не приложение Visual Studio 2019). Выберите элемент Командная строка разработчика для VS 2019, чтобы открыть окно командной строки.

Открытие командной строки разработчика в Visual Studio 2017

Если вы установили Visual Studio 2017 в Windows 10 или более поздней версии, откройте меню «Пуск» и выберите Все приложения. Прокрутите вниз и откройте папку Visual Studio 2017 (не приложение Visual Studio 2017). Выберите элемент Командная строка разработчика для VS 2017, чтобы открыть окно командной строки.

Открытие командной строки разработчика в Visual Studio 2015

Если вы установили Microsoft Visual C++ Build Tools 2015 в Windows 10 или более поздней версии, откройте меню «Пуск» и выберите Все приложения. Прокрутите вниз и откройте папку Microsoft Visual C++ Build Tools. Выберите элемент Командная строка Native Tools x86 Visual C++ 2015, чтобы открыть окно командной строки.

Если вы используете другую версию Windows, найдите в меню «Пуск» или на начальной странице папку средств Visual Studio, содержащую ярлык командной строки разработчика. Можно также ввести «командная строка разработчика» в строке поиска в Windows и выбрать командную строку, которая соответствует установленной версии Visual Studio. Откройте окно командной строки с помощью ярлыка.

Затем убедитесь в том, что командная строка разработчика Visual C++ настроена правильно. В окне командной строки введите cl и убедитесь в том, что выходные данные выглядят примерно так:

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

Если при выполнении команды cl появляется сообщение о том, что «cl не распознается как внутренняя или внешняя команда, исполняемая программа или пакетный файл», или возникают ошибки C1034 или LNK1104, дело в том, что вы не используете командную строку разработчика или что-то не так с установкой Visual C++. Для продолжения нужно будет исправить ошибку.

Если вы не можете найти ярлык командной строки разработчика или при вводе cl появляется сообщение об ошибке, возможно, возникла проблема с установкой Visual C++. При использовании Visual Studio 2017 или более поздней версии попробуйте переустановить рабочую нагрузку Разработка классических приложений на C++ с помощью установщика Visual Studio. Подробные сведения см. в статье Справка по установке средства С++ в Visual Studio. Можно также переустановить Build Tools со страницы Загрузки Visual Studio. Не переходите к следующему разделу, пока команда cl не сработает. Дополнительные сведения об установке Visual Studio и устранении неполадок см. в статье Установка Visual Studio.

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

Создание файла исходного кода на языке C и его компиляция из командной строки

В окне блокнота введите следующие строки кода:

В строке меню блокнота выберите Файл > Сохранить, чтобы сохранить файл hello.c в рабочей папке.

Имя исполняемой программы (hello.exe) отображается в информации, выводимой компилятором.

Если вы получаете сообщение об ошибке, например «cl не распознается как внутренняя или внешняя команда, исполняемая программа или пакетный файл», ошибке C1034 или LNK1104, командная строка разработчика настроена неправильно. Чтобы получить сведения о том, как устранить эту проблему, вернитесь к разделу Открыть командную строку разработчика.

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

Программа выводит следующий текст и затем закрывается:

Поздравляем! Вы скомпилировали и запустили программу на C с помощью командной строки.

Следующие шаги

Этот пример Hello, World является самой простой программой C. Реальные программы выполняют полезные действия и имеют файлы заголовков, дополнительные исходные файлы и ссылки на библиотеки.

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

cl file1.c file2.c file3.c

Компилятор выдает программу с именем file1.exe. Чтобы изменить имя на program1.exe, добавьте параметр компоновщика /out:

cl file1.c file2.c file3.c /link /out:program1.exe

Чтобы автоматически перехватывать другие ошибки программирования, рекомендуется выполнить компиляцию с помощью порога предупреждений /W3 или /W4:

cl /W4 file1.c file2.c file3.c /link /out:program1.exe

Компилятор cl.exe имеет множество других параметров, которые можно применять для создания, оптимизации, отладки и анализа кода. Чтобы просмотреть краткий список, введите cl /? в командной строке разработчика. Можно также выполнять компиляцию и компоновку отдельно и применять параметры компоновщика в более сложных сценариях сборки. Дополнительные сведения о параметрах и использовании компилятора и компоновщика см. в справочнике по сборке для C/C++.

Для настройки и создания более сложных проектов в командной строке можно использовать NMAKE и файлы makefile либо MSBuild и файлы проекта. Дополнительные сведения об использовании этих средств см. в разделах Справочник по NMAKE и MSBuild.

Языки C и C++ похожи, но имеют различия. Компилятор Microsoft C/C++ (MSVC) использует простое правило для определения языка, используемого при компиляции кода. По умолчанию компилятор MSVC рассматривает все файлы с расширением .c как исходные коды на языке С, а файлы с расширением .cpp как исходные коды на языке С++. Если указан параметр компилятора /TC, компилятор будет рассматривать все файлы как исходные коды на языке С вне зависимости от расширения.

Некоторые функции библиотеки и имена функций POSIX являются нерекомендуемыми в компиляторе MSVC. Функции поддерживаются, но предпочтительные имена изменились. Дополнительные сведения см. в статьях Функции безопасности в CRT и Предупреждение компилятора (уровень 3) C4996.

Источник

Пошаговое руководство. Компиляция собственной программы на языке C++ из командной строки

В этом пошаговом руководстве приводятся инструкции по созданию программы на языке C++ в стиле «Hello, Wolrd» в текстовом редакторе с последующей компиляцией из командной строки. Если вы хотите попробовать интегрированную среду разработки Visual Studio вместо командной строки, см. статью Пошаговое руководство. Работа с проектами и решениями (C++) или Использование интегрированной среды разработки Visual Studio для разработки приложений для настольных систем на языке C++.

В этом пошаговом руководстве вместо ввода показанного кода можно использовать собственную программу на языке C++. Также можно использовать пример кода C++ из другой статьи справки.

Предварительные требования

Для выполнения этого пошагового руководства необходимо установить Visual Studio и дополнительную рабочую нагрузку Разработка настольных приложений на C++ или Build Tools командной строки для Visual Studio.

Visual Studio — интегрированная среда разработки (IDE). Она поддерживает полнофункциональный редактор, диспетчеры ресурсов, отладчики и компиляторы для многих языков и платформ. Доступные версии включают бесплатный выпуск Visual Studio Community Edition, и все они могут поддерживать разработку на C и C++. Сведения о скачивании и установке Visual Studio см. в статье Установка поддержки C++ в Visual Studio.

Build Tools для Visual Studio устанавливают только средства, библиотеки и компиляторы командной строки, необходимые для сборки программ C и C++. Это идеальный вариант для создания заданий и упражнений, а установка выполняется относительно быстро. Чтобы установить только средства командной строки, найдите Build Tools для Visual Studio на странице загрузки Visual Studio.

Прежде чем можно будет выполнить сборку программ C или C++ в командной строке, убедитесь, что эти средства установлены и к ним можно получить доступ из командной строки. Visual C++ имеет сложные требования к среде командной строки для поиска используемых средств, заголовков и библиотек. Visual C++ нельзя использовать в простом окне командной строки без предварительной подготовки. К счастью, Visual C++ устанавливает ярлыки для запуска командной строки разработчика, для которой настроена среда для сборок из командной строки. К сожалению, имена ярлыков командной строки разработчика и места их расположения отличаются практически во всех версиях Visual C++ и в различных версиях Windows. Первая задача пошагового руководства — найти нужную командную строку.

Ярлык командной строки разработчика автоматически задает правильные пути для компилятора и средств, а также для всех необходимых заголовков и библиотек. Эти значения среды необходимо задавать самостоятельно, если используется обычное окно командной строки. Дополнительные сведения см. в статье Использование набора инструментов MSVC из командной строки. Рекомендуется использовать ярлык командной строки разработчика вместо создания собственного.

Открытие командной строки разработчика

Если вы установили Visual Studio 2017 или более поздней версии в Windows 10 или более поздней версии, откройте меню «Пуск» и выберите Все приложения. Прокрутите вниз и откройте папку Visual Studio (не приложение Visual Studio). Выберите элемент Командная строка разработчика для VS, чтобы открыть окно командной строки.

Если вы установили Microsoft Visual C++ Build Tools 2015 в Windows 10 или более поздней версии, откройте меню Пуск и выберите Все приложения. Прокрутите вниз и откройте папку Microsoft Visual C++ Build Tools. Выберите элемент Командная строка Native Tools x86 Visual C++ 2015, чтобы открыть окно командной строки.

Можно также ввести «командная строка разработчика» в строке поиска в Windows и выбрать командную строку, которая соответствует установленной версии Visual Studio. Откройте окно командной строки с помощью ярлыка.

Затем убедитесь в том, что командная строка разработчика Visual C++ настроена правильно. В окне командной строки введите cl и убедитесь в том, что выходные данные выглядят примерно так:

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

Если при выполнении команды cl появляется сообщение о том, что «cl не распознается как внутренняя или внешняя команда, исполняемая программа или пакетный файл», или возникают ошибки C1034 или LNK1104, дело в том, что вы не используете командную строку разработчика или что-то не так с установкой Visual C++. Для продолжения нужно будет исправить ошибку.

Если вы не можете найти ярлык командной строки разработчика или при вводе cl появляется сообщение об ошибке, возможно, возникла проблема с установкой Visual C++. Попробуйте переустановить компонент Visual C++ в Visual Studio или Microsoft Visual C++ Build Tools. Не переходите к следующему разделу, пока команда cl не сработает. Дополнительные сведения об установке Visual C++ и устранении неполадок см. в статье Установка Visual Studio.

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

Создание файла исходного кода на языке Visual C++ и его компиляция из командной строки

Когда Блокнот предложит создать файл, выберите Да. Откроется пустое окно Блокнота, в котором можно ввести код для файла hello.cpp.

В окне блокнота введите следующие строки кода:

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

Сохраните файл. В Блокноте, в меню Файл выберите Сохранить.

Поздравляем, вы создали исходный файл C++ hello.cpp, который готов к компиляции.

Вернитесь к окну командной строки разработчика. Введите dir в командной строке, чтобы получить список содержимого каталога c:hello. Вы увидите исходный файл hello.cpp в списке каталогов, который выглядит примерно так:

Даты и некоторые другие данные будут отличаться на вашем компьютере.

Компилятор cl.exe создаст OBJ-файл, содержащий скомпилированный код, а затем запустит компоновщик для создания исполняемой программы с именем hello.exe. Это имя отображается в строках информации, выводимой компилятором. Выходные данные компилятора должны выглядеть следующим образом:

Если вы получаете сообщение об ошибке, например «cl не распознается как внутренняя или внешняя команда, исполняемая программа или пакетный файл», ошибке C1034 или LNK1104, командная строка разработчика настроена неправильно. Чтобы получить сведения о том, как устранить эту проблему, вернитесь к разделу Открыть командную строку разработчика.

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

Программа выводит следующий текст и закрывается:

Поздравляем, вы скомпилировали и запустили программу C++ с помощью средств командной строки.

Следующие шаги

Этот пример «Hello, World» является самой простой программой C++. Реальные программы обычно имеют файлы заголовков, дополнительные исходные файлы и ссылки на библиотеки.

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

Чтобы скомпилировать программу с дополнительными файлами исходного кода, введите их все в командной строке, например:

cl /EHsc file1.cpp file2.cpp file3.cpp

Параметр командной строки /EHsc указывает компилятору на необходимость стандартной обработки исключений C++. В противном случае созданные исключения могут привести к неуничтоженным объектам и утечкам ресурсов. Дополнительные сведения см. в статье /EH (модель обработки исключений).

При указании дополнительных исходных файлов компилятор использует первый входной файл для создания имени программы. В этом случае выводится программа с именем file1.exe. Чтобы изменить имя на program1.exe, добавьте параметр компоновщика /out:

cl /EHsc file1.cpp file2.cpp file3.cpp /link /out:program1.exe

Чтобы автоматически перехватывать другие ошибки программирования, рекомендуется выполнить компиляцию с помощью порога предупреждений /W3 или /W4:

cl /W4 /EHsc file1.cpp file2.cpp file3.cpp /link /out:program1.exe

В компиляторе cl.exe есть множество дополнительных параметров. Их можно применять для создания, оптимизации, отладки и анализа кода. Чтобы просмотреть краткий список, введите cl /? в командной строке разработчика. Можно также выполнять компиляцию и компоновку отдельно и применять параметры компоновщика в более сложных сценариях сборки. Дополнительные сведения о параметрах и использовании компилятора и компоновщика см. в справочнике по сборке для C/C++.

Для настройки и создания более сложных проектов в командной строке можно использовать NMAKE и файлы makefile, MSBuild и файл проекта или CMake. Дополнительные сведения об использовании этих средств см. в разделах Справочник по NMAKE, MSBuild и Проекты CMake в Visual Studio.

Языки C и C++ похожи, но имеют различия. Компилятор MSVC использует простое правило для определения языка, используемого при компиляции кода. По умолчанию компилятор MSVC рассматривает файлы с расширением .c как исходные файлы на языке С, а файлы с расширением .cpp — как исходные файлы на языке С++. Если указан параметр компилятора /TP, компилятор будет рассматривать все файлы как исходные файлы на языке С++ вне зависимости от расширения.

Компилятор MSVC содержит библиотеку времени выполнения C (CRT), которая соответствует стандарту ISO C99 с небольшими исключениями. Переносимый код обычно компилируется и выполняется, как ожидалось. Некоторые устаревшие функции библиотеки и несколько имен функций POSIX не рекомендуется использовать в компиляторе MSVC. Функции поддерживаются, но предпочтительные имена изменились. Дополнительные сведения см. в статьях Функции безопасности в CRT и Предупреждение компилятора (уровень 3) C4996.

Источник

Источник

На занятии Вы рассмотрите тему «язык С++: структура программы и создание проекта в C++»

Содержание:

  • Алгоритм работы при создании C++-проекта в Visual Studio
    • Типы переменных
    • Структура программы в C++
    • C++ стандартная библиотека (std)
    • C++ синтаксис
  • Лабораторные работы

Алгоритм работы при создании C++-проекта в Visual Studio

1. New Project: Создание проекта.

  1. Пункт меню File -> New -> Project (Файл -> Создать -> Проект).
  2. В открывшемся окне в разделе Project Types (Установленные) найти Visual C++.
  3. В разделе Templates (Шаблоны) выбрать Win32 Console Application (Консольное приложение Win32).
  4. Указать имя нового «решения» (Solution Name) и имя проекта (Name).
  5. Сохранить проект на локальном диске в легко доступном месте (например, D:Projects).
  6. Можно снять галочку Create folder for solution (Создать каталог для решения), чтобы не множить каталоги без необходимости.
  7. В следующем диалоговом окне щелкнуть Далее и затем выбрать Application Settings (Дополнительные параметры) -> Empty Project (Пустой проект). Убрать галочку с пункта Проверки жизненного цикла…

2. Add files: Добавление файлов.
Правый клик на проекте в окне Solution Explorer (Обозреватель решений) — пункт Add (Добавить) — пункт Create New Item (Создать элемент) или Add existing Item (Существующий элемент). Для этого и любого другого проекта понадобится как минимум один файл с точкой входа в программу — функцией main.

3. Exclude files: Исключение файлов.
Сначала удобно создать один проект и добавлять в него по одному файлу с решением каждой отдельной задачи. Однако при этом возникает проблема: в нескольких файлах проекта присутствует функция main, что противоречит правилам C++. Для решения данной проблемы, необходимо «исключать» файлы из проекта (правый клик на файле, Exclude from project (Исключить)). При этом файлы исчезнут из окна проекта, однако сохранятся в каталоге проекта на диске.

Типы переменных

  • C++ — это строго типизированный язык программирования.
  • В C++ существует два вида переменных — переменные примитивного типа или переменные пользовательского типа.

    • То есть типы делятся на:

  • Примитивные
  • Пользовательские

    • Примитивные типы
    Их 6 в C++:

  • int, (4) целые числа
  • char, (1) символы
  • bool, (1) логический (true или false)
  • float, (4) вещественные числа
  • double, (8) вещественные двойной точности
  • void, отсутствие занчения

    • и еще:

  • short int (2) // или short
  • unsigned int (4) // или unsigned
  • unsigned char (1) // byte

    • Пользовательские типы
    Два наиболее часто используемых:

  • std::string, строка (последовательность символов)
  • std::vector, динамический массив

Структура программы в C++

В программе C++ program есть точка входа — это функция int main()
По соглашению функция возвращает 0, если программа выполнена успешно и не ноль — при наличии ошибок.
Пример:

int main() {
  int i= 4;
  i = i + 2;
  char c = 'a';
  std::cout << i << " " << c << std::endl; // вывод
  return 0;
}

C++ стандартная библиотека (std)

Стандартная библиотека (std) предоставляет часто используемую функциональность и возможность использования некоторых структур данных.
Стандартная библиотека C++ состоит из множества внутренних библиотек которые могут быть подключены к любой программе (#included).
Так, директива (заголовок) iostream включает операции по вводу и выводу в файл и консоль:

#include <iostream>
int main() {
	std::cout << "Hello, world!" << std::endl;
	system("pause");
        return 0;
}

Вся функциональность стандартной библиотеки являются частью пространства имен std. Если какая-то функциональность из пространства имен используется часто, то она также может быть подключена, с помощью оператора using:

#include <iostream>
using std::cout;
using std::endl;
int main() {
	cout << "Hello, world!" << endl;
	system("pause");
        return 0;
}

или импортирование самого пространства имен std:

#include <iostream>
using namespace std;
int main() {
	cout << "Hello, world!" << endl;
	system("pause");
        return 0;
}

C++ синтаксис

Инициализация переменных в C++11

double d { 3.14 };
auto s { "C++" };
int i { 3.7 }; // error!
char c { 128 }; // error!
bool b { -1 }; // error!
int j { true }; // OK, j == 1

Неявное преобразование

При присваивании вещественного числа целочисленной переменной, дробная часть будет отброшена

char c = 128; // warning: constant value truncation
bool b = -1; // true – warning: truncation from "int" to "bool"

Арифметические операции

C++

a = 4;
a += 2; // a = a+2;
b = a++; 
b = ++a; 
7 / 3  
7 % 3 
(i < 0 || i > 2) 
(i >= 2 && i <= 3) 
!(i>2) 
==
!=
& | ^ ~  
a = b = c;
 PascalABC.NET

a := 4;
a += 2;
t := a; a++; b := t;
a++; b := a;
7 div 3
7 mod 3
(i < 0) or (i > 2)
(i >= 2) and (i <= 3)
not(i>2)
=
<>
bitwise and, or, xor, not
b:=c; a:=c;

Блок видимости переменных

Блок кода, определенный скобками { }, создает внутренний стэк сверху текущего стэка памяти. Благодаря чему переменные внутри блока «спрятаны». Т.о. область видимости переменных и их жизненный цикл определяется данным блоком. Переменные, определенные внутри блока, существуют, пока существует блок.

#include <iostream>
int main() {
  // Внешняя область:
  int x = 2;
  std::cout << "Значение x во внешней области (должно быть 2): " << x << std::endl;
 
  // Создается внутренний блок и переменная в нем с именем "x".
    {
    int x = 3;
    int y = 4;
    std::cout << "Значение x во внутреннем блоке (должно быть 3): " << x << std::endl;
    std::cout << "Значение y во внутреннем блоке (должно быть 4): " << y << std::endl;
  }
 
  // Внутренний блок закрылся, внутренние переменные x и y исчезли.
 
  std::cout << "Значение x во внешней области (должно быть  2): " << x << std::endl;
 
  // К переменной y здесь уже обращаться нельзя!
    return 0;
}

Условные операторы

Оператор If

Оператор if может иметь свой внутренний блок, обозначенный фигурными скобками { }. Тогда «время жизни» условного оператора определяется временем жизни данного блока:

#include <iostream>
using namespace std;
int main() {
  int x = 2;
  cout << "x во внешней области видимости (= 2): " << x << endl;
 
  if (true) {
    int x = 3;
    cout << "x во внутреннем блоке (= 3): " << x << endl;
  }
 
  cout << "x из внешней видимости (= 2): " << x << endl;
 
  return 0;
}

If-Else

if (condition) {
    // если true
}
else {
    // если false
}

Цепочка условий:

if (condition1) {
 
}
else if (condition2) {
 
}
else if (condition3) {
 
}
else {
    // если все условия ложны
}

Тернарный оператор

Syntax:

[логическое условие] ? [оператор если условие true] : [оператор если условие false]
// Так как (5<10) = true, будет извлечен оператор, находящийся после двоеточия, то есть <code>1</code>.
int x = 5 < 10 ? 1 : 2;
// x = 1

Оператор выбора Switch

Syntax:

switch (проверяемая переменная) {
	case значение1:
		// что-то выполняется 
		break;
	case значение2:
		// что-то выполняется 
		break;
	case значение3:
		// что-то выполняется 
		break;
	…
 
	default:
		// что-то выполняется  если ни одно из условий не было истинным
	}

Циклы

В с++ есть несколько видов циклов, которые позволяют выполнить повторяющиеся действия.
Цикл for
Цикл for состоит из трех компонентов: инициализация счетчика цикла, условие для счетчика, шаг изменения счетчика. Синтаксис:

for ( инициализация; условие; шаг ) { тело цикла }
#include <iostream>
using namespace std;
int main() {
 
  // инициализация "x" во внешней области видимости 
  int x = -1;
 
  // 
  for (int x = 0; x <= 2; x++) {
    cout << "[Inside the loop] x is now: " << x << endl; // 0  ..  1 ..  2
  }
 
  // В цикле for позволяет счетчик цикла объявляется в заголовке цикла, 
  // т.о. счетчик будет принадлежать внутренней области блока:
  for (x = 0; x <= 2; x++) {
    cout << "[внутри цикла] x : " << x << endl;
  }
 
  return 0;
}

Цикл while
синтаксис:

while (условие) 
{ 
  тело цикла 
}

Цикл do-while
синтаксис:

do 
   { 
      тело цикла  
   }
while (условие)

Лабораторные работы

Лабораторная работа 0. Вывод приветствия в консоль (стандартный поток вывода)

Выполнение:

    Часть 1:

  1. Создайте новый проект с названием MyFirstProject (алгоритм создания проекта см. выше).
  2. В окне Обозреватель решений выполните правый клик на папке Файлы исходного кода и выберите пункт Добавить -> Создать элемент -> Файл С++ (cpp). В поле Имя файла введите main.cpp. Щелкните Добавить
  3. В первой строке файла добавим директиву include для подключения внешних файлов-библиотек:
  4. Далее подключим глобальные пространства имен:
    5. using std::cout;
using std::cin;
using std::endl;
  5. Добавьте главную функцию main (){} и вставьте в нее инструкцию вывода в консоль слов «Привет мир!»
    6. int main(){
  cout<< "Hello World!";
}

    операторы вывода:

    или вывод значения переменной:

  6. чтобы консольное окно не исчезало сразу, добавим паузу:
    7. int main(){
  cout<< "Hello World!";
  system("pause");
}
  7. Откомпилируйте и запустите проект. Посмотрите результат.
  • Для ввода данных применяется стандартный потоковый объект cin, который использует операцию >>. Справа от этого знака находится переменная, принимающая вводимую информацию.
  • Для вывода данных применяется стандартный потоковый объект cout, который использует операцию <<. Справа от этого знака находится литерал или переменная, значение которой выводится.
  • Использование объектов cin и cout возможно, потому что в программе подключен файл iostream

Лабораторная работа 1: Обычный вывод и ввод
Выполнить: Создайте консольное приложение для ввода числа, увеличения его на единицу и выводу результата в консоль.

Примерный вывод:

Введите число: 4
Результат: 5

[file nameL1Lab1.cpp]

✍ Алгоритм:

  1. Откройте Microsoft Visual Studio. Выберите в меню Файл -> Новый проект. В секции Тип проекта выберите C++ и затем Win32 Консольное приложение.
  2. В окне Обозреватель решений найдите папку Файлы источники щелкните правой кнопкой мыши, чтобы добавить новый файл Даобавить -> New Item. Мы собираемся создать новый .cpp файл. Назовите его L1lab1.cpp.
  3. Добавьте следующий код в созданный файл:

    4. Директива iostreamсодержит функции ввода/вывода в файлы или консоль.

  4. Далее введите код функции Main:
    5. int main() {
		// …
}

    Функция main является точкой входа программы на C++. Здесь начинается компиляция проекта

  5. В функции main добавьте объявление переменной x с типом integer (целое число):
  6. Запросите ввести число:
    7. std::cout << "Введите число: ";
  7. Используйте библиотеку std для сохранения введенного значения в переменной x:
    8. ...
 std::cin >> x;
...
  8. Увеличим x на единицу:
  9. Выведите результат в консоль:
    10. std::cout << "Result: " << x << std::endl;

    Оператор endl выполняет переход на новую строку.

  10. Обычно функция main должна возвращать 0. Добавьте код в самом конце данной функции:

    11. return 0;

  11. Запустите приложение. Консольное окно быстро пропадает. Необходимо его задержать на экране
  12. Добавьте для этого паузу:
    13.   …
   system("pause");
   return 0;
}
  13. Запустите приложение снова.

    14.   
    Импортирование функциональности из библиотеки std:

  14. Для того чтобы постоянно не добавлять область имен std, импортируем в проект некоторые из ее функций. Добавьте следующий код в самое начало кода проекта, в область заголовков:
    15. using std::cout;
using std::cin;
using std::endl;

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

  15. Теперь можно убрать префикс std перед выводом cout и вводом cin данных:
    16. cout << "Введите число: ";
…
cin >> x;
…
cout << "Результат: " << x << endl;
  16. Запустите приложение.

    17.  
    Импортирование пространства имен std:

  17. Вместо того чтобы выводить конкретные функции библиотеки std, можно импортировать саму библиотеку. Для этого необходимо добавить в область заголовков:
    18.  using namespace std;
  18. Запустите проект снова.
Источник

Создание и чтение файлов в C++

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

Чтобы использовать библиотеку fstream, подключите как стандартный файл , так и заголовочный файл :

#include <iostream>
#include <fstream> 

В библиотеку fstream включены три класса, которые используются для создания, записи или чтения файлов:

Описание класса

ofstream — Создает и записывает в файлы
ifstream — Читает из файлов
fstream — Комбинация ofstream и ifstream: создание, чтение и запись в файлы.

Создание и запись файла

Чтобы создать файл, используйте класс ofstream или fstream и укажите имя файла.

Для записи в файл используйте оператор вставки (<<).

Пример:

#include <iostream>
#include <fstream>
using namespace std;

int main() {
  // создание и открытие текстового файла
  ofstream MyFile("filename.txt");

  // Запись в файл
  MyFile << "Hello, from Myrusakov!";

  // Закрытие файла
  MyFile.close();
} 

Почему мы закрываем файл?

Это считается хорошей практикой и может очистить ненужное пространство памяти.

Чтение из файла.

Для чтения из файла используйте класс ifstream или fstream и имя файла.

Обратите внимание, что мы также используем цикл while вместе с функцией getline() (которая принадлежит классу ifstream) для чтения файла построчно и для печати содержимого файла:



// Создание строковой переменной, для вывода содержимого файла
string myText;

// Чтение из текстового файла
ifstream MyReadFile("filename.txt");

// Использование цикла while  совместно с функцией getline()  для построчного чтения файла
while (getline (MyReadFile, myText)) {
  // вывод текста из файла
  cout << myText;
}

// Закрытие файла
MyReadFile.close(); 

Таким образом, мы создали и прочитали данные из файла в C++.

  • Создано 16.06.2022 13:58:12


  • Михаил Русаков

Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!

Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.

Если Вы не хотите пропустить новые материалы на сайте,
то Вы можете подписаться на обновления: Подписаться на обновления

Если у Вас остались какие-либо вопросы, либо у Вас есть желание высказаться по поводу этой статьи, то Вы можете оставить свой комментарий внизу страницы.

Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):

  1. Кнопка:

    Она выглядит вот так: Как создать свой сайт

  2. Текстовая ссылка:

    Она выглядит вот так: Как создать свой сайт

  3. BB-код ссылки для форумов (например, можете поставить её в подписи):
Источник

Понравилась статья? Поделить с друзьями:
  • Как создать ярлык папки на рабочем столе в windows 11
  • Как создать файл cfg на windows 10 через блокнот
  • Как создать ярлык панель управления на рабочем столе в windows 10
  • Как создать учетную запись через cmd windows 7
  • Как создать ярлык панели управления windows 10