C++ для начинающих. Создание программ из нескольких файлов (Знакомство)

Опубликовано 26.09.2012 | Автор: admin

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

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

Файл реализации — это файл, в котором реализуется основная часть программы. Если главный файл называть центром управления, то файл реализации — это механизм, которым управляют.

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

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

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

Для понимания необходимо знать:

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

#include <iostream>

using namespace std;

int main(){
	cout << "Hello";
	cin.get();
}

#include <iostream>

using namespace std;

int main(){

cout << "Hello";

cin.get();

}

Cоздание файлов в обычном блокноте и формирование из них программы в Borland C++ 3.1

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

Создаём каталог, в котором напишем три файла.

В зависимости от вашего способа работы с компилятором пути могут быть отличны от описываемых мной. В случае прямой работы с компилятором, пути обычны и корневой диск системы в большинстве случаев C:\, но в случае работы с DosBox корневым диском системы считается не фактический диск C:\, а каталог, куда распакован Borland C++ 3.1. Т. е. C:\ на самом деле может быть каким-нибудь каталогом. Вам нужно самостоятельно сориентироваться, что у вас.

У меня DosBox, поэтому для меня путь C:\ в настоящей системе C:\Borland. (Зависит от места, куда распаковывали, оттуда мы запускаем ярлык Borland C++)

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

Создаём основной файл проекта. Как правило, основной файл всегда содержит функцию main. Сейчас можно создать просто пустую программу, название файла можно давать произвольное, но расширение файлу, по общему соглашению, следует давать .cpp. К тому же в Borland C++3.1 нужно давать очень короткие имена, из-за 16 разрядов операционной системы MS-DOS даже мало-мальски длинные он проглотить не способен.

Я назову свой файл "Project.cpp"

Project.cpp

int main(){}

1	int main(){}

Теперь там же создадим файл реализации, т. е. файл, в котором реализуем нужные нам функции. Поскольку нам необходима только одна функция, то её и опишем, полностью. Я назову файл реализации Realis.cpp. По общему соглашению файлам реализации имеет смысл давать расширени .cpp. А названия должны быть говорящими, прежде всего, чтобы вы сами не путались в файлах, когда их будет много. Чем понятнее название файла — тем проще жить всем. Не забываем, что у нас очень сильное ограничение на длину имени. Т. е. нужно придумать короткое имя, но при этом понятное.

Realis.cpp

#include <iostream.h>		//для cout и  cin

void foo(const char* S){
	cout << S << endl;
	cin.get();				//для задержки
}

#include <iostream.h> //для cout и cin

void foo(const char* S){

cout << S << endl;

cin.get(); //для задержки

}

Теперь, чтобы связать основной файл с файлом реализации, нужно создать отдельный файл. Файл общих очертаний или, правильно называя, файл заголовков. В таком файле обычно пишут прототипы функций и объявляют переменные, но не описывают функции и не задействуют переменные. Такие файлы, как правило, называют также, как и файлы реализации, но дают расширение им .h. Это расширение происходит из первой буквы слова Headers (заголовки). А одноимённость позволяет понимать, что вот у этого файла такая-то реализация, а у другого файла такая-то. Когда файлов много это имеет очень важное значение для незапутывания.

Realis.h

void foo(const char*);	//Прототип функции foo, реализованной в другом файле

1	void foo(const char*); //Прототип функции foo, реализованной в другом файле

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

Запускаем Borland C++ 3.1, теперь мы работаем непосредственно с ним. Полноценный код программы уже написан.

Для собственного удобства меняем основную директорию с помощью меню. У меня файлы лежат в C:\Prog (ранее я поснял, что в настоящей системе это, в моём случае, путь C:\Borland\Prog, но в DosBox C:\Borland считается диском С:\)

Теперь встаём на путь создания проекта. Для этого в меню жмём Project->Open project

Меняем звёздочку на любое название (можно удобным названием проекта) и жмём Enter

Если всё правильно сделано, то видите приблизительно такой вид:

Осталось добавить файлы с расширением .cpp в создаваемый проект. Исользуем меню: Project -> Add item.

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

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

Теперь, щёлкнув по файлу двойным кликом, можно открыть текст файла в окне. Нас интересует основной файл программы, для сборки. Основной файл и кликаем.

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

Когда мы подключаем собственноручно созданные файлы с помощью include, тогда мы включаемые файлы должны заворачивать в двойные кавычки.

Немного меняем код:

Project.cpp

#include "Realis.h"		//Поключаем заголовочный файл (будет контейнером прототипов)

int main(){
	foo("HELLO");		//Задействуем функцию из другого файла
	return 0;
}

#include "Realis.h" //Поключаем заголовочный файл (будет контейнером прототипов)

int main(){

foo("HELLO"); //Задействуем функцию из другого файла

return 0;

}

Если всё сделано верно, то запускаем и наслаждемся плодами труда:

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

Раньше, когда Borland C++ 3.1 был популярен, стандартным подходом была работа (в том числе и из командной строки), где шаги были следующими:

Создание отдельного каталога
Запуск из него IDE или переход в него по File — Change Dir
Project — Open — задание имени файлу проекта
Добавление в проект необходимого минимума файлов (пока имен)
Enter в проекте открывает файл на редактирование

Cоздание многофайлового проекта из Visual Studio 2015

Проект можно создавать как полностью вручную, так и из под коробки. Я для примера использую Visual Studio 2015, с помощью которой покажу оба варианта.

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

Запускаем Visual Studio. Выбираем файл -> Создать -> Проект.

Выбираем нужный нам вид проекта. Пока мы учимся, мы в основном работаем с консольным приложением, поэтому нужно выбираь консольный вариант. Можно создавать не консольное приложение, а пустой проект:

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

У нас открылся обозреватель решений, в котором отображается небольшая иерархия:

Если вы не видите обозреватель решений, тогда используйте меню: Вид -> Обозреватель решений.

В обозревателе решений мы можем легко управлять добавлением новых файлов в проект. Кликаем правой кнопкой мыши на "Файлы исходного кода" и левой по "Добавить -> Создать элемент". Вам предлагается создать или заголовочный файл, или файл С++. Мы будем создавать и то, и это, но постепенно.

Первым делом имеет смысл добавить основной файл программы, который будет содержать в себе функцию main. Это файл С++, выбираем и жмём "Добавить".

Пишем код. Сейчас этот код — это только пустая функция main:

int main(){

}

int main(){

}

Этот созданный сейчас файл будет иметь смысл центра управления поведением программы. Теперь мы создаём другой файл, в котором пишем какие-нибудь функции. Их можно много писать, но в нашем случае я использую только написание одной функции. Повторяем добавление файла, снова выбираем файл С++ и пишем код:

#include <iostream>

using namespace std;

void foo(const char* S){
	cout << S << endl;
}

#include <iostream>

using namespace std;

void foo(const char* S){

cout << S << endl;

}

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

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

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

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

Такого вида файлы — это заголовочные файлы, опять добавляем файл, как и ранее, но выбираем "Заголовочный файл". И пишем в созданный файл код:

#pragma once
	void foo(const char* S);	//Прототип функции foo

1 2	#pragma once void foo(const char* S); //Прототип функции foo

Теперь всё готово. Осталось только задействовать функцию foo из центра управления программой. Выбираем вкладку основного файла, файла с функцией main и дописываем код:

#include "Header.h"
#include <iostream>		//для cin

using std::cin;

int main() {
	foo("Hello");
	foo("World");

	cin.get();	//Для задержки окна
}

#include "Header.h"

#include <iostream> //для cin

using std::cin;

int main() {

foo("Hello");

foo("World");

cin.get(); //Для задержки окна

}

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

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

Защита от повторного включения реализуется директивами препроцессора:

			#ifndef SYMBOL
			#define SYMBOL

			// набор объявлений

			#endif

#ifndef SYMBOL

#define SYMBOL

// набор объявлений

#endif

Поэтому защитим нашу функцию в заголовочном файле:

#pragma once		//Это защита от двойного подключения (нестандарт, но распространено)


#ifndef SOMETHING	//И это защита от двойного подключения (часто делают именно так)
#define SOMETHING
	void foo(const char* S);	//Прототип функции foo
#endif

#pragma once //Это защита от двойного подключения (нестандарт, но распространено)

#ifndef SOMETHING //И это защита от двойного подключения (часто делают именно так)

#define SOMETHING

void foo(const char* S); //Прототип функции foo

#endif

На самом деле можно использовать один из двух способов защиты (или pragma, или ifndef), их сочетать ни к чему. Но знать имеет смысл оба, а так же понимать, то pragma — нестандарт. Поэтому попробуйте привыкнуть ко второму варианту защиты.

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

Сборка файлов в проект с помощью Visual Studio 2015

Общий принцип создания многофайловых проектов из-под коробки я объяснил, теперь объясню, как открывать созданное кем-то. В Visual C++ делается это очень просто. Пусть у нас будет некоторый каталог с 3 файлами внутри: главный файл программы, файл реализации и заголовочный файл, который помогает основному файлу знать о существовании функций, написанных внутри файла реализации.

main_file.cpp

C++

#include "header_file.h" #include <iostream> using std::cin; int main(){ foo("Hello"); foo("World"); cin.get(); }

1
2
3
4
5
6
7
8
9
10
11

#include "header_file.h"
#include <iostream>

using std::cin;

int main(){
foo("Hello");
foo("World");

cin.get();
}
realis_file.cpp

C++

#include <iostream> using std::cout; using std::endl; void foo(const char* S){ cout << S << endl; }

1
2
3
4
5
6
7
8

#include <iostream>

using std::cout;
using std::endl;

void foo(const char* S){
cout << S << endl;
}
header_file.cpp

C++

void foo(const char* S);

1

void foo(const char* S);

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

Файл -> Проект из существующего кода:

Поскольку пишем на С++, выбираем Visual C++ и жмём "Далее" После чего выбираем папку с нашими файлами и обязательно называем наш проект любым именем:

Жмём "Далее" и выбираем консольное приложение:

Жмём "Готово". Немного ждём сборку. И после сборки, задействуя обозреватель решений и зная главный файл программы, можем запускать программу на исполнение. Если не знаем главный файл программы, пробуем найти файл реализации с функцией main. Как нашли, его и запускаем. Наслаждаемся.

Сборка файлов в проект с помощью CodeBlocks

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

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

Я создаю 3 файла в каталоге C:\prog

main_file.cpp
realis_file.cpp
header_file.h

main_file.cpp

#include "header_file.h"
#include <iostream>

using std::cin;

int main(){
	foo("Hello");
	foo("World");

	cin.get();
}

#include "header_file.h"

#include <iostream>

using std::cin;

int main(){

foo("Hello");

foo("World");

cin.get();

}

realis_file.cpp

#include <iostream>

using std::cout;
using std::endl;

void foo(const char* S){
	cout << S << endl;
}

#include <iostream>

using std::cout;

using std::endl;

void foo(const char* S){

cout << S << endl;

}

header_file.h

void foo(const char* S);

1	void foo(const char* S);

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

Поскольку мы собираем проект, то создаём пустой проект: File -> New project, где выбираем пустой проект: Empty project и жмём Go, чем подтверждаем выбор.

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

Теперь в этот пустой проект нам нужно добавит файлы. Поскольку все файлы уже имеются, мы можем легко их добавить скопом, задействова пункт меню Рекурсивное добавление файлов. Project->Add files recursively…

Теперь нам остаётся только выбрать папку с лежащими в ней исходниками и подтвердить выбор. Поскольку у меня исходники лежат в папке C:\Prog, именно эту папку я и выбираю. Если всё правильно, то вы видите приблизительно такое окно, в котором при необходимости можно будет снимать галочки с файлов, случайно затесавшихся в нужные. В моём случае всего три файла, все три я и добавляю, поэтому галочки не снимаю и жму OK.

В следующем окошке появляется возможность установки флпжков Debug/Release. Можете поставить оба флажка. Я не хочу заморачивать вам головы, к чему они нужны, у меня другая цель. Так что смело ставите два флажка и жмёте ОК.

Всё, файлы загрузились. Вам даже может показаться, что ничего не произошло, но проект на самом деле подготовлен. Вам нужно обратить внимание на окно Management. Если этого окна не видите, попробуйте включить его отображение с помощью меню: View -> Manager. Ваша задача найти окошко и потыркавшись в нём найти загруженные файлы.

Остаётся найти главный файл программы, сделать его активным в CodeBlocks и запустить на исполнение. Обычно в главном файле всегда есть функция main. (Хотя некоторые программы могут не содержать main вообще, но мы идём простым путём и для облегчения понимания самого процесса не вдаёмся в глубокие подробности). Я знаю, какой у меня главный файл, потому что я его назвал самодокументированным именем. Поэтому без труда нахожу и запускаю. Результат:

Вот и всё.

Создание многофайлового проекта в CodeBlocks

Многофайловые проекты можно создавать не только вручную, откуда-то извне IDE, но и с помощью самой IDE CodeBlocks. Для этого нужно обязательно создавать новый проект.

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

Порядок создания файлов будет такой:

Сначала основной файл программы, этот файл будет выполнять роль центра управления поведением программы.

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

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

Создаём основной файл программы. Этот файл всегда файл реализации, т. е. его расширение .cpp. При выборе языка (нам предлагают или С, или С++) выбираем С++, мы же на С++ пишем. Называем файл каким-нибудь именем. Название его не имеет особого значения, но лучше называть самодокументированным именем, легче будет ориентироваться, когда файлов придётся писать много. Назову его main_file, что обозначит, что файл главный. После вписывания имени не поленитесь нажать на три точки и выберите удобный путь для сохранения, или просто нажмите ОК, просто если вы не нажмёте этого троеточия, то попытка закончить начатое может спровоцировать возникновение ошибки.

В созданный файл пишем код. Пока что пишем просто пустую функцию main.
main_file.cpp

int main(){

}

int main(){

}

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

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

Второй файл, который мы будем добавлять — это файл, в котором мы напишем нужные функции. Поскольку у нас в задаче надо задействовать одну функцию, только эту одну функцию мы и напишем в отдельном файле. Мы пишем функцию полностью, т. е. реализуем функцию, следовательно делаем файл реализации, т. е. файл с расширением .cpp. Повторяем процесс добавления нового файла. Я назову этот файл file_realis. И напишу в него код:

file_realis.cpp

#include <iostream>

using std::cout;

int foo(const char* S){
    cout << S << endl;
}

#include <iostream>

using std::cout;

int foo(const char* S){

cout << S << endl;

}

Теперь у нас есть и главный файл программы, и файл, который можно использовать как часть программы. Всё, что нам нужно, это подсказать компилятору, какие функции стоит ждать. Это можно сделать или вручную, заявив в главный файл прототип функции foo(const char* S);, или создать ещё один файл, в котором и заявить прототип функции. Лучше способ именно с созданием третьего файла.

Способ с явным задействованием прототипа в главном файле программы, где вы просто дописываете прототип функции:

main_file.cpp

void foo(const char* S);        //Заявили в основной файл прототип используемой в ходе написания кода функции

int main(){
    foo("Hello");
}

void foo(const char* S); //Заявили в основной файл прототип используемой в ходе написания кода функции

int main(){

foo("Hello");

}

Если всё правильно сделано, то запуская на выполнение главный файл программы, мы видим выхлоп в виде работающей программы!

Но прототипы лучше выносить в отдельный файл. Это, как минимум, замечательное удобство в дальнейшем. Поэтому мы просто добавляем ещё один файл, но в этот раз создаём заголовочный файл, т. е. файл с расширением .h и вписываем прототип в него. После чего подключаем в главном файле созданный заголовочный файл с помощью препроцессорной директивы #include

Я назову заголовочный файл именем Header_file

Header_file.h

#ifndef HEADER_FILE_H_INCLUDED
#define HEADER_FILE_H_INCLUDED

    void foo(const char* S);      //Прототип функции

#endif // HEADER_FILE_H_INCLUDED

#ifndef HEADER_FILE_H_INCLUDED

#define HEADER_FILE_H_INCLUDED

void foo(const char* S); //Прототип функции

#endif // HEADER_FILE_H_INCLUDED

И подключу в главном файле программы этот заголовочный файл:

main_file.cpp

#include "Header_file.h"

int main(){
    foo("Hello");
    foo("World");
}

#include "Header_file.h"

int main(){

foo("Hello");

foo("World");

}

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

НАВЕРХ

Рубрика: Знакомства, Многофайловые проекты, Раздельная компиляция

Светлана:

18.09.2017 в 3:49 пп

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

Ответить

Последние комментарии

Александр к записи Хороший стиль программирования
Аноним к записи Список тем сайта
Аноним к записи Список тем сайта