Export translations

Settings

Group

Language

Format

Export for off-line translation

Export in native format

Export in CSV format

{{DISPLAYTITLE:KDevelop4/Manual/Работа с исходным кодом}}<languages />

== Работа с исходным кодом ==

Отладка, чтение и написание исходного кода — это то, на что у Вас будет уходить основное время при разработке программного обеспечения. С этой целью '''KDevelop''' предоставляет Вам множество различных возможностей в изучении исходного кода и более продуктивном его написании. В следующих разделах рассказывается что '''KDevelop''' является не только редактором исходного кода &mdash; он скорее является системой управления исходным кодом, которая даёт Вам различные представления информации о содержимом файлов с исходным кодом, которые в совокупности представляют собой сеансы.


=== Инструменты и служебные панели ===

[[Image:kdevelop-7.png|thumb|500px|center]]

Для работы с проектами в '''KDevelop''' используются ''инструменты''. Инструмент обеспечивает некоторое представление объекта с которым предназначен работать или действий, которые могут быть выполнены над ним. Инструменты представлены в виде кнопок, находящихся по краю окна (вертикально по левому или правому краям, либо горизонтально по нижнему краю). При нажатии на такую кнопку, в главном окне открывается служебная панель с инструментом. Если же нажать на эту кнопку снова — панель скроется.

<div class="mw-translate-fuzzy">
{{Note/ru|1=Чтобы скрыть служебную панель можно также нажать кнопку <menuchoice>x</menuchoice> в правой части заголовка панели. Однако, по крайней мере в последних версиях '''KDevelop''' 4.2.x, это так же приведёт к исчезновению кнопки, представляющую инструмент на границе окна. Как вернуть потерянную кнопку обратно, равно как и кнопку любого другого инструмента, описано ниже. Данное поведение описано в отчёте об ошибках [http://bugs.kde.org/show_bug.cgi?id=270018 bug 270018]}}
</div>

Изображение, приведённое выше, показывает служебные панели, расположенные по левому и правому краям. Панель <menuchoice>Classes</menuchoice> (<menuchoice>Классы</menuchoice> в русском переводе) открыта слева, а панель <menuchoice>Snippets</menuchoice> (<menuchoice>Фрагменты</menuchoice> в русском переводе) — справа от редактора исходного кода, размещённого в середине. На практике Вы вероятнее всего будете пользоваться преимущественно панелями <menuchoice>Классы</menuchoice> и <menuchoice>Code Browser</menuchoice> (<menuchoice>Обозреватель кода</menuchoice> в русском переводе), открытыми слева. Остальные панели вероятнее всего будут открываться на время необходимое для работы с ними, оставляя в основное рабочее время всё свободное пространство редактору кода.

Когда Вы запустите '''KDevelop''', Вы должны увидеть кнопку панели инструментов <menuchoice>Проекты</menuchoice>. Нажав её, откроется окно панели, которая снизу отобразит проекты открытые в существующей сессии, а сверху иерархию директорий и файлов открытых проектов.

Есть много [[Special:myLanguage/KDevelop4/Manual/Tool_list|иных служебных панелей ]] которые можно использовать в '''KDevelop''', кнопки которых не все изначально присутствуют на границах главного окна. Чтобы добавить интересующую панель следует выбрать пункт меню <menuchoice>Окно -> Добавить служебную панель</menuchoice>. Вот некоторые из тех, что могут оказаться полезными:

* '''Классы''': Полный список всех классов, определённых в одном из проектов или всей открытой сессии со всеми их методоми и свойствами. При двойном клике на любой из элементов, откроется редактор кода в месте объявления выбранного элемента.

* '''Документы''': Список некоторых ранее просматриваемых файлов по видам (например, исходные файлы, патчи, текстовые документы)

* '''Обозреватель кода''': в зависимости от положения курсора в файле, этот инструмент показывает вещи, которые связаны между собой. Например, если вы находитесь на <code>#include</code>, он покажет информацию о включаемом файле, вы в том числе, например, какие классы объявленные в том файле. Если вы находитесь на пустой строке, он показывает классы и функции, объявленные и определенных в текущем файле (все они представлены в виде ссылок: нажав на них, вы попадете в точку в файле, где находится их объявление или определение), если вы находитесь в определении функции, он показывает, где она объявлена и предлагает список мест, где функция используется.

* '''Файловая система''': Показывает файловую систему в виде дерева.

* '''Документация''': Предлагает поиск man-страниц и другой документации.

* '''Фрагменты''': предоставляет последовательности текста, который то и дело используется кем-то, кто не желает этот текст писать каждый раз. Например, в проекте, из которого был создан рисунок выше, существует частая необходимость в коде, как 
{{Input|1=<nowiki>for (typename Triangulation&lt; dim&gt;::active_cell_iterator cell
 = triangulation.begin_active();
 cell != triangulation.end();
 ++cell)</nowiki>}} Выражение является громоздким и будет выглядеть фактически именно так всякий раз, когда Вам нужен такой цикл. Для того, чтобы не писать его каждый раз и повторно использовать, это выражение является хорошим кандидатом быть фрагментом (от '''snippet''' (англ.) - фрагмент, отрывок).

* '''Консоль''': открывает окно командной строки внутри основного окна '''KDevelop''' для ввода команд, которые Вы, может быть, время от времени хотите выполнять (например, запустить <code>./configure</code>)

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


=== Анализ исходного кода ===

==== Локальные данные ====

'''KDevelop''' ''понимает'' исходный код, и, как следствие, надлежащим образом обеспечивает информацией о переменных и функциях, которые могут появиться в Вашей программе. Например, здесь есть рабочий снимок с фрагментом кода и наведением курсора мыши на символ <code>cell</code> в строке 1316 (если Вы работаете с приспособленной для этого клавиатурой, Вы можете достичь того же эффекта, нажав и удерживая клавишу <keycap>Alt</keycap>):

[[Image:kdevelop-13.png|thumb|600px|center]]

'''KDevelop''' показывает всплывающую подсказку с информацией о типе переменной (здесь: <code>DoFHandler&lt;dim&gt;active_cell_iterator</code>), где эта переменная объявлена (''контейнер'', здесь это выделенная функция <code>get_maximal_velocity</code>, так как это локальная переменная), что это (переменная; не функция, класс или пространство имён) и где это объявлено (в строке 1314, буквально несколько строк выше по тексту).

В данной ситуации символ, на который был наведён курсор мыши, не имеет соотнесённой с ним информации. Если установить курсор мыши на <code>get_this_mpi_process</code> в строке 1318, то в результате получилось бы это:

[[Image:kdevelop-14.png|thumb|600px|center]]

Здесь '''KDevelop''' использовал перекрёстную ссылку на совершенно другой файл (<code>utilities.h</code>, который фактически даже находится в другом проекте того же сеанса) вместе с комментарием в формате doxygen, который там сопутствует объявлению.

Ещё более полезными всплывающие подсказки делает то, что они являются динамическими: можно щёлкнуть по контейнеру для получения информации о контексте, где объявлена переменная (то есть данные о пространстве имён <code>System</code>, например то, где это объявлено, определено, использовано, или информацию о документации) и можно щёлкнуть по синим ссылкам, что установит курсор на позицию объявления символа (например, в <code>utilities.h</code>, строка 289) или покажет список мест, где этот символ используется в текущем файле или во всех проектах текущего сеанса. Последняя возможность будет полезной, если Вы хотите изучить, например, как используется отдельная функция в большой кодовой базе.

{{Note/ru|1=Всплывающая подсказка с информацией быстро исчезает &mdash; всё зависит от удерживания нажатой клавиши <keycap>Alt</keycap> или наведения курсора мыши на фрагмент кода. Если Вы хотите зафиксировать данные из подсказки, откройте панель инструментов <menuchoice>Обозреватель кода</menuchoice>. Например, здесь курсор расположен на той же самой функции, как и раньше, а на панели инструментов слева показана та же информация, что и на подсказке:

[[Image:kdevelop-15.png|thumb|500px|center]]

Перемещение курсора в правой части окна будет приводить к изменению данных в его левой части. Нажав на кнопку <menuchoice>Lock current view</menuchoice> наверху справа, Вы сможете зафиксировать данные, оградив их от изменений из-за расположения курсора во время просмотра.}}

{{Note/ru|1=Доступ к контекстным данным такого типа можно получить из многих частей '''KDevelop''', не только из редактора текстов программ. Удерживание нажатой клавиши <keycap>Alt</keycap> в словаре для автоматического заполнения при написании кода (например, быстро открыв) также дает контекстную информацию для текущего символа.}}

==== Информация относительно отдельного файла ====

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

[[Image:kdevelop-16.png|thumb|600px|center]]

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

{{Note/ru|1=Эти данные по всему файлу совпадают с представленными данными в режиме "Обзор", обсуждение которого идёт ниже в разделе навигации в исходном коде. Разница состоит в том, что в режиме обзора информация отображается только на временной панели подсказок.}}

==== Информация относительно проекта и сеанса ====

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

[[Image:kdevelop-17.png|thumb|600px|center]]

Hovering over an entry provides again information about the symbol, its location of declaration and definition, and its uses. Double-clicking on an entry in this tree view opens an editor window at the location where the symbol is declared or defined.

But there are other ways of looking at global information. For example, the <menuchoice>Documents</menuchoice> tool provides a view of a project in terms of the kinds of files or other documents this project is comprised of:

[[Image:kdevelop-18.png|thumb|600px|center]]

==== Rainbow color highlighting explained ====

'''KDevelop''' uses a variety of colors to highlight different objects in source code. If you know what the different colors mean, you can very quickly extract a lot of information from source code just by looking at the colors, without reading a single character. The highlighting rules are as follows:

* Objects of type Class / Struct, Enum (the values and the type), (global) functions, and class members each have their own color assigned (classes are green, enums are dark red, and members are dark yellow or violet, (global) functions are always violet).

* All global variables are colored in dark green.

* Identifiers which are typedefs for another type are colored in teal.

* All declarations and definitions of objects are in bold.

* If a member is accessed from within the context where it is defined (base or derived class) it appears in yellow, otherwise it appears in violet.

* If a member is private or protected, it gets colored in a slightly darker color when used.

* For variables local to a function body scope, rainbow colors are picked based on a hash of the identifier. This includes the parameters to the function. An identifier always will have the same color within its scope (but the same identifier will get a different color if it represents a different object, i.e. if it is redefined in a more nested scope), and you will usually get the same color for the same identifier name in different scopes. Thus, if you have multiple functions taking parameters with the same names, the arguments will all look the same color-wise.

* Identifiers for which '''KDevelop''' could not determine the corresponding declaration are colored in white. This can sometimes be caused by missing <code>#include</code> directives.

* In addition to that coloring, the normal editor syntax highlighting will be applied, as known from '''Kate'''. '''KDevelop's''' semantic highlighting will always override the editor highlighting if there is a conflict.

{{Note| Rainbow coloring of local variables can be turned off in <menuchoice>Settings...->Configure KDevelop...->Language Support->Local colorization intensity</menuchoice> by setting the slider control to its minimum value. Similarly colorization of global variables, global functions, classes, structs, enums, and class members can be turned off in <menuchoice>Settings...->Configure KDevelop...->Language Support->Global colorization intensity</menuchoice> }}

=== Navigating in source code ===

In the previous section, we have discussed exploring source code, i.e. getting information about symbols, files and projects. The next step is then to jump around your source base, i.e. to navigate in it. There are again various levels at which this is possible: local, within a file, and within a project.

{{Note|1=Many of the ways to navigate through code are accessible from the <menuchoice>Navigate</menuchoice> menu in the '''KDevelop''' main window.}}

==== Local navigation ====

'''KDevelop''' is much more than an editor, but it is ''also'' a source editor. As such, you can of course move the cursor up, down, left or right in a source file. You can also use the <keycap>PageUp</keycap> and <keycap>PageDown</keycap> keys, and all the other commands you are used from any useful editor.

==== File scope navigation and outline mode ====

At the file scope, '''KDevelop''' offers many possible ways to navigate through source code. For example:

* '''Outline''': You can get an outline of what's in the current file in at least three different ways:
** Clicking into the <menuchoice>Outline</menuchoice> textbox at the top right of the main window, or hitting <keycap>Alt + Ctrl + N</keycap> opens a drop-down menu that lists all function and class declarations: [[Image:kdevelop-19.png|thumb|600px|center]] You can then just select which one to jump to, or &mdash; if there are a lot &mdash; start typing any text that may appear in the names shown; in that case, as you keep typing, the list becomes smaller and smaller as names are removed that don't match the text already typed until you are ready to select one of the choices.
** Positioning the cursor at file scope (i.e. outside any function or class declarations or definitions) and having the <menuchoice>Code Browser</menuchoice> tool open: [[Image:kdevelop-16.png|thumb|600px|center]] This also provides you an outline of what is happening in the current file, and allows you to select where you want to jump to.
** Hovering the mouse over the tab for one of the open files also yields an outline of the file in that tab.

* Source files are organized as a list of function declarations or definitions. Hitting <keycap>Alt + Ctrl + PgUp</keycap> and <keycap>Alt + Ctrl + PgDown</keycap> jumps to the previous or next function definition in this file.

==== Project and session scope navigation: Semantic navigation ====

As mentioned in other places, '''KDevelop''' does not usually consider individual source files but rather looks at projects as a whole (or, rather, at all projects that are part of the current session). As a consequence, it offers many possibilities for navigating through entire projects. Some of these are derived from what we have already discussed in the section on [[Special:myLanguage/KDevelop4/Manual/Working with source code#Exploring source code|Exploring source code]] while others are genuinely different. The common theme is that these navigation features are based on a ''semantic understanding'' of the code, i.e. they offer you something that requires parsing entire projects and connecting data. The following list shows some ways how to navigate through source code that is scattered throughout a potentially very large number of files:

* As seen in the section on [[Special:myLanguage/KDevelop4/Manual/Working with source code#Exploring source code|Exploring source code]], you can get a tooltip explaining individual namespace, class, function or variable names by hovering your mouse over it or keeping the <keycap>Alt</keycap> key pressed for a while. Here is an example: [[Image:kdevelop-14.png|thumb|500px|center]] Clicking on the links for the declaration of a symbol or expanding the list of uses allows you to jump to these locations, if necessary opening the respective file and placing the cursor at the corresponding location. A similar effect can be achieved by using the '''Code Browser''' tool view also discussed previously.

* '''Quick open''': A very powerful way of jumping to other files or locations is to use the various ''quick open'' methods in '''KDevelop'''. There are four versions of these:
** '''Quick open class''' (<menuchoice>Navigate -> Quick open class</menuchoice> or <keycap>Alt + Ctrl + C</keycap>): You will get a list of all classes in this session. Start typing (a part of) the name of a class and the list will continue to whittle down to only those that actually match what you've typed so far. If the list is short enough, select an element using the up and down keys and '''KDevelop''' will get you to the place where the class is declared.
** '''Quick open function''' (<menuchoice>Navigate -> Quick open function</menuchoice> or <keycap>Alt + Ctrl + M</keycap>): You will get a list of all (member) functions that are part of the projects in the current session, and you can select from it in the same way as above. Note that this list may include both function declarations and definitions.
** '''Quick open file''' (<menuchoice>Navigate -> Quick open file</menuchoice> or <keycap>Alt + Ctrl + O</keycap>): You will get a list of all files that are part of the projects in the current session, and you can select from it in the same way as above.
** '''Universal quick open''' (<menuchoice>Navigate -> Quick open</menuchoice> or <keycap>Alt + Ctrl + Q</keycap>): If you forget which key combination is bound to which of the above commands, this is the universal swiss army knife &mdash; it simply presents you with a combined list of all files, functions, classes, and other things from which you can select.

* '''Jump to declaration/definition''': When implementing a (member) function, one often needs to switch back to the point where a function is declared, for example to keep the list of function arguments synchronised between declaration and definition, or to update the documentation. To do so, place the cursor onto the function name and select <menuchoice>Navigation -> Jump to declaration</menuchoice> (or hit <keycap>Ctrl + .</keycap>) to get to the place where the function is declared. There are multiple ways to get back to the original place:
** Selecting <menuchoice>Navigation -> Jump to definition</menuchoice> (or hitting <keycap>Ctrl + ,</keycap>).
** Selecting <menuchoice>Navigation -> Previous visited context</menuchoice> (or hit <keycap>Meta + Left</keycap>), as described below.

{{Note|1=Jumping to the declaration of a symbol is something that does not only work when placing the cursor on the name of the function you are currently implementing. Rather, it also works for other symbols: Putting the cursor on a (local, global, or member) variable and jumping to its declaration also transports you to its location of declaration. Similarly, you can place the cursor on the name of a class, for example in a variable of function declaration, and jump to the location of its declaration.}}

* '''Switch between declaration/definition''': In the example above, to jump to the site of the declaration of the current function, you need to first place the cursor on the function name. To avoid this step, you can select <menuchoice>Navigation -> Switch definition/declaration</menuchoice> (or hit <keycap>Shift + Ctrl + C</keycap>) to jump to the declaration of the function within which the cursor currently is. Selecting the same menu entry a second time transports you back to the place where the function is defined.

* '''Previous/Next use''': Placing the cursor on the name of a local variable and selecting <menuchoice>Navigation -> Next use</menuchoice> (or hitting <keycap>Meta + Shift + Right</keycap>) transports you to the next use of this variable in the code. (Note that this doesn't just search for the next occurrence of the variable name but in fact takes into account that variables with the same name but in different scopes are different.) The same works for the use of function names. Selecting <menuchoice>Navigation -> Previous use</menuchoice> (or hitting <keycap>Meta + Shift + Left</keycap>) transports you to the previous use of a symbol.

{{Note|1=To see the list of all uses of a name through which these commands cycle, place the cursor onto it and open the <menuchoice>Code Browser</menuchoice> tool view or press and hold the <keycap>Alt</keycap> button. This is explained in more detail in the section on [[Special:myLanguage/KDevelop4/Manual/Working_with_source_code#File_scope_information|Exploring code]].}}

{{Note|Some shortcuts might be used already by your window manager (e.g. <keycap>Meta + Left</keycap> is used by LXDE/Openbox); you can either change the key combination for the shortcut in kdevelop <menuchoice>Settings...->Configure Shortcuts</menuchoice> or in the window manager config (e.g. .config/openbox/lubuntu-rc.xml)}}

* The '''context list''': Web browsers have this feature where you can go backward and forward in the list of most recently visited web pages. '''KDevelop''' has the same kind of features, except that instead of web pages you visit ''contexts''. A context is the current location of the cursor, and you change it by navigating away from it using anything but cursor commands &mdash; for example, by clicking on a location provided by a tooltip, in the <menuchoice>Code Browser</menuchoice> tool view, one of the options given in the <menuchoice>Navigation</menuchoice> menu, or any other navigation command. Using the <menuchoice>Navigation -> Previous Visited Context</menuchoice> (<keycap>Meta + Left</keycap>) and <menuchoice>Navigation -> Next Visited Context</menuchoice> (<keycap>Meta + Right</keycap>) transports you along this list of visited contexts just like the <menuchoice>back</menuchoice> and <menuchoice>forward</menuchoice> buttons of a browser transports you to the previous or next webpage in the list of visited pages.

* Finally, there are tool views that allow you to navigate to different places in your code base. For example, the '''Classes''' tool provides you with a list of all namespaces and classes in all projects of the current session, and allows you to expand it to see member functions and variables of each of these classes: [[Image:kdevelop-17.png|thumb|500px|center]] Double-clicking on an item (or going through the context menu using the right mouse button) allows you to jump to the location of the declaration of the item. Other tools allow similar things; for example, the <menuchoice>Projects</menuchoice> tool view provides a list of files that are part of a session: [[Image:kdevelop-13.png|thumb|500px|center]] Again, double-clicking on a file opens it.

=== Writing source code ===

Because '''KDevelop''' understands your projects' source code, it can assist in writing more code. The following outlines some of the ways in which it does that.

==== Auto-completion ====

Probably the most useful of all features in writing new code is auto-completion. Consider, for example, the following piece of code:

{{Input|<syntaxhighlight lang="cpp">
class Car {
 // ...
 public:
 std::string get_color () const;
};

void foo() 
{
 Car my_ride;
 // ...do something with this variable...
 std::string color = my_ride.ge
</syntaxhighlight>}}

In the last line, '''KDevelop''' will remember that the variable <code>my_ride</code> is of type <code>Car</code>, and will automatically offer to complete the name of the member function <code>ge</code> as <code>get_color</code>. In fact, all you have to do is to keep typing until the auto-completion feature has reduced the number of matches to one, and then hit the <keycap>Enter</keycap> key:

[[Image:kdevelop-42.png|thumb|500px|center]]

Note that you can click on the tool-tip to get more information about the function apart from its return type and whether it is public:

[[Image:kdevelop-43.png|thumb|500px|center]]

Auto-completion can save you a lot of typing if your project uses long variable and function names; furthermore, it avoids mis-spelling names (and the resulting compiler errors) and it makes it much simpler to remember the exact names of functions; for example, if all of your getters start with <code>get_</code>, then the auto-completion feature will be able to only present you a list of possible getters when you have typed the first four letters, likely reminding you in the process which of the functions is the correct one. Note that for auto-completion to work, neither the declaration of the <code>Car</code> class nor of the <code>my_ride</code> variable need to be in the same file as where you are currently writing code. '''KDevelop''' simply has to know that these classes and variables are connected, i.e. the files in which these connections are made need to be part of the project you are currently working on.

{{Note|1='''KDevelop''' doesn't always know when to assist you in completing code. If the auto-completion tooltip doesn't automatically open, hit <keycap>Ctrl + Space</keycap> to open a list of completions manually. In general, in order for auto-completion to work, '''KDevelop''' needs to parse your source files. This happens in the background for all files that are part of the projects of the current session after you start '''KDevelop''', as well as while after you stop typing for a fraction of a second (the delay can be configured).}}

{{Note|1='''KDevelop''' only parses files that it considers source code, as determined by the MIME-type of the file. This type isn't set before the first time a file is saved; consequently, creating a new file and starting to write code in it will not trigger parsing for auto-completion until after it is saved for the first time.}}

{{Note|1=As in the previous note, for auto-completion to work, '''KDevelop''' must be able to find declarations in header files. For this, it searches in a number of default paths. If it doesn't automatically find a header file, it will underline the name of a header file in red; in that case, right click on it to tell '''KDevelop''' explicitly where to find these files and the information they provide.}}

{{Note|1=Configuring auto-completion is discussed in [[KDevelop4/Manual/Customizing_KDevelop#Customizing_code_auto-completion|this section of this manual]].}}

==== Adding new classes and implementing member functions ====

'''KDevelop''' has an assistant for adding new classes. The procedure is described in [[Special:myLanguage/KDevelop4/Manual/Code generation with templates#Creating a new class|Creating a new class]]. A simple C++ class can be created by choosing the Basic C++ template from the <tt>Class</tt> category. In the assistant, we can choose some predefined member functions, for example an empty constructor, a copy constructor and a destructor.

After completing the assistant, the new files are created and opened in the editor. The header file already has include guards and the new class has all the member functions we selected. The next two steps would be to document the class and its member functions and to implement them. We will discuss aids for documenting classes and functions below. To implement the special functions already added, simply go to the <menuchoice>bus.cpp</menuchoice> tab where the skeleton of functions are already provided:

[[Image:kdevelop-30.png|thumb|500px|center]]

To add new member functions, go back to the <menuchoice>bus.h</menuchoice> tab and add the name of a function. For example, let us add this:

[[Image:kdevelop-31.png|thumb|500px|center]]

Note how I have already started with the implementation. However, in many coding styles, the function shouldn't be implemented in the header file but rather in the corresponding .cpp file. To this end, locate the cursor on the name of the function and select <menuchoice>Code -> Move to source</menuchoice> or hit <keycap>Ctrl + Alt + S</keycap>. This remove the code between curly braces from the header file (and replaces it by a semicolon as necessary to terminate the function declaration) and moves it into the source file:

[[Image:kdevelop-32.png|thumb|500px|center]]

Note how I have just started typing and that I meant to imply that the <code>students</code> variable should probably be a member variable of class <code>Bus</code> but that I haven't yet added it. Note also how '''KDevelop''' underlines it to make clear that it doesn't know anything about the variable. But this problem can be solved: Clicking on the variable name yields the following tooltip:

[[Image:kdevelop-33.png|thumb|500px|center]]

(The same can be achieved by right clicking on it and selecting <menuchoice>Solve: Declare As</menuchoice>.) Let me select "3 - private unsigned int" (either by mouse, or by hitting <keycap>Alt + 3</keycap>) and then see how it comes out in the header file:

[[Image:kdevelop-34.png|thumb|500px|center]]

It is worth noting that '''KDevelop''' extracts the type of the variable to be declared from the expression used to initialize it. For example, if we had written the addition in the following rather dubious way, it would had suggested to declare the variable as type <code>double</code>:

[[Image:kdevelop-35.png|thumb|500px|center]]

As a final point: The method using <menuchoice>Code -> Move to source</menuchoice> does not always insert the new member function where you may want it. For example, you may want it to be marked as <code>inline</code> and place it at the bottom of the header file. In a case like this, write the declaration and the start writing the definition of the function like this:

[[Image:kdevelop-36.png|thumb|500px|center]]

'''KDevelop''' automatically offers all possible completions of what might come here. Selecting one of the two <code>add_students</code> entries yields the following code that already fills in the complete argument list:

[[Image:kdevelop-37.png|thumb|500px|center]]

==== Documenting declarations ====

Good code is well documented, both at the level of the implementation of algorithms within functions, as well as at the level of the interface &mdash; i.e., classes, (member and global) functions, and (member or global) variables need to be documented to explain their intent, possible values of arguments, pre- and postconditions, etc. As far as documenting the interface is concerned, [http://www.doxygen.org doxygen] has become the de facto standard for formatting comments that can then be extracted and displayed on searchable webpages.

'''KDevelop''' supports this style of comments by providing a short cut to generate the framework of comments that document a class or member function. For example, assume you have already written this code:

{{Input|<syntaxhighlight lang="cpp">
class Car {
 public:
 std::string get_color () const;
};
</syntaxhighlight>}}

You now want to add documentation to both the class and the member function. To this end, move the cursor onto the first line and select <menuchoice>Code -> Document Declaration</menuchoice> or hit <keycap>Alt + Shift + D</keycap>. '''KDevelop''' will respond with the following:

[[Image:kdevelop-23.png|thumb|550px|center]]

The cursor is already in the grayed out area for you to fill in the short description (after the doxygen keyword <code>@brief</code>) of this class. You can then continue to add documentation to this comment that gives a more detailed overview of what the class does:

[[Image:kdevelop-24.png|thumb|550px|center]]

While the editor is inside the comment, the comment text is highlighted in green (the highlighting disappears once you move the cursor out of the comment). When you get to the end of a line, hit <keycap>Enter</keycap> and '''KDevelop''' will automatically start a new line that starts with an asterisk and place the cursor one character indented.

Now let's document the member function, again by putting the cursor on the line of the declaration and selecting <menuchoice>Code -> Document Declaration</menuchoice> or hitting <keycap>Alt + Shift + D</keycap>:

[[Image:kdevelop-25.png|thumb|550px|center]]

Again, '''KDevelop''' automatically generates the skeleton of a comment, including documentation for the function itself, as well as its return type. In the current case, the name of the function is pretty much self-explanatory, but oftentimes function arguments may not be and should be documented individually. To illustrate this, let's consider a slightly more interesting function and the comment '''KDevelop''' automatically generates:

[[Image:kdevelop-26.png|thumb|550px|center]]

Here, the suggested comment already contains all the Doxygen fields for the individual parameters, for example.

==== Renaming variables, functions and classes ====

Sometimes, one wants to rename a function, class or variable. For example, let's say we already have this:

[[Image:kdevelop-38.png|thumb|550px|center]]

We then realize that we're unhappy with the name <code>remove_students</code> and would have rather called it, say, <code>throw_out_students</code>. We could do a search-replace for the name, but this has two drawbacks:

* The function may be used in more than one file.

* We really only want to rename this function and not touch functions that may have the same name but are declared in other classes or namespaces.

Both these problems can be solved by moving the cursor on any of the occurrences of the name of the function and selecting <menuchoice>Code -> Rename declaration</menuchoice> (or right clicking on the name and selecting <menuchoice>Rename Bus::remove_students</menuchoice>). This brings up a dialog box where you can enter the new name of the function and where you can also see all the places where the function is actually used:

[[Image:kdevelop-39.png|thumb|550px|center]]

==== Code snippets ====

Most projects have pieces of code that one frequently has to write in source code. Examples are: for compiler writers, a loop over all instructions; for user interface writers, checks that user input is valid and if not to open an error box; in the project of the author of these lines, it would be code of the kind

{{Input|<syntaxhighlight lang="cpp">
for (typename Triangulation<dim,spacedim>::active_cell_iterator
 cell = triangulation.begin_active();
 cell != triangulation.end(); ++cell)
 ... do something with the cell ...
</syntaxhighlight>}}

Rather than typing this kind of text over and over again (with all the concomitant typos one introduces), the <menuchoice>Snippets</menuchoice> tool of '''KDevelop''' can help here. To this end, open the tool view (see [[Special:myLanguage/KDevelop4/Manual/Working with source code#Tools and views|Tools and views]] if the corresponding button isn't already on the perimeter of your window). Or, go to <menuchoice>Window -> Tool views</menuchoice> in the top menubar, and turn on <menuchoice>Snippets</menuchoice>. Then click on the <menuchoice>Add repository</menuchoice>button (a slight misnomer &mdash; it allows you to create a named collection of snippets for source codes of a particular kind, e.g. C++ sources) and create an empty repository. Then click {{Plus}} to add a snippet, to get a dialog like the following:

[[Image:kdevelop-40.png|thumb|500px|center]]

{{Note|1=The name of a snippet may not have spaces or other special characters because it must look like a normal function or variable name (for reasons that will become clear in the next paragraph). If the name of the snippet does contain spaces, the <menuchoice>OK</menuchoice> button will become inactive without any further explanation. This has been fixed in recent versions of KDevelop (see [https://bugs.kde.org/show_bug.cgi?id=274299 KDevelop bug 274299]).}}

To use a snippet so defined, when you are editing code, you can just type the name of the snippet like you would any other function or variable name. This name will become available for auto-completion &mdash; which means that there is no harm in using a long and descriptive name for a snippet such as the one above &mdash; and when you accept the suggestion of the auto-completion tooltip (for example by just hitting <keycap>Enter</keycap>), the already entered part of the snippets' name will be replaced by the full expansion of the snippet and will be properly indented:

[[Image:kdevelop-41.png|thumb|500px|center]]

Note that for this to work, the <menuchoice>Snippets</menuchoice> tool view need not be open or visible: you only ever need the tool view to define new snippets. An alternative, if less convenient, way to expand a snippet is to simply click on it in the respective tool view.

{{Note|1=Snippets are much more powerful than just explained. For a full description of what you can do with them, see the [[Special:myLanguage/KDevelop4/Manual/Tool_list/Snippets|detailed documentation of the Snippets tool]].}}
=== Modes and working sets ===

[[Image:kdevelop4_noworkingset.png|thumb|300px|center]]

If you've gotten this far, take a look at the upper right of the '''KDevelop''' main window: As shown in the picture, you will see that there are three '''modes''' '''KDevelop''' can be in: <menuchoice>Code</menuchoice> (the mode we discuss in the current chapter on working with source code), <menuchoice>Debug</menuchoice> (see [[Special:myLanguage/KDevelop4/Manual/Debugging programs|Debugging programs]]) and <menuchoice>Review</menuchoice> (see [[Special:myLanguage/KDevelop4/Manual/Working with version control systems|Working with version control systems]]).

[[Image:kdevelop4_sessionsprojectsworkingsets.png|thumb|250px|center]]

Each mode has its own set of tools that are stacked around the perimeter, and each mode also has a ''working set'' of currently open files and documents. Furthermore, each such working set is associated with a current session, i.e. we have the relationship shown above. Note that the files in the working set come from the same session, but they may come from different projects that are part of the same session.

If you open '''KDevelop''' the first time, the working set is empty &mdash; there are no open files. But as you open files for editing (or debugging, or reviewing in the other modes) your working set grows. The fact that your working set is non-empty is indicated by a symbol in the tab, as shown below. You will notice that whenever you close '''KDevelop''' and later start it again, the working set is saved and restored, i.e. you get the same set of open files.

[[Image:kdevelop-10.png|thumb|300px|center]]

If you hover your mouse over the symbol for the working set, you get a tooltip that shows you which files are currently open in this working set (here: the <code>step-32.cc</code> and <code>step-1.cc</code> files). Clicking on the red minus sign closes the tab for the corresponding file. Maybe more importantly, clicking on the correspondingly named button allows you to '''close''' the entire working set at once (i.e. to close all currently open files). The point about closing a working set, however, is that it doesn't just close all files, it actually saves the working set and opens a new, still empty one. You can see this here:

[[Image:kdevelop-11.png|thumb|300px|center]]

Note the two symbols to the left of the three mode tabs (the heart and the unidentifiable symbol to its left). Each of these two symbols represents a saved working set, in addition to the currently open working set. If you hover your mouse over the heart symbol, you'll get something like this:

[[Image:kdevelop-12.png|thumb|600px|center]]

It shows you that the corresponding working set contains two files and their corresponding project names: <code>Makefile</code> and <code>changes.h</code>. Clicking <menuchoice>Load</menuchoice> will close and save the current working set (which as shown here has the files <code>tria.h</code> and <code>tria.cc</code> open) and instead open the selected working set. You can also permanently delete a working set, which removes it from the set of saved working sets.
=== Some useful keyboard shortcuts ===

'''KDevelop's''' editor follows the standard keyboard shortcuts for all usual editing operations. However, it also supports a number of more advanced operations when editing source code, some of which are bound to particular key combinations. The following are frequently particularly helpful:

{| border="1" cellspacing="0"
!colspan="2"  style="background-color:#ffff99;" | Jumping around in code
|-

| <keycap>Ctrl+Alt+O</keycap>
| Quick open file: enter part of a filename and select among all the files in the current session's projects' directory trees that match the string; the file will then be opened
|-

| <keycap>Ctrl+Alt+C</keycap>
| Quick open class: enter part of a class name and select among all class names that match; the cursor will then jump to the class declaration
|-

| <keycap>Ctrl+Alt+M</keycap>
| Quick open function: enter part of a (member) function name and select among all names that match; note that the list shows both declarations and definitions and the cursor will then jump to the selected item
|-

| <keycap>Ctrl+Alt+Q</keycap>
| Universal quick open: type anything (file name, class name, function name) and get a list of anything that matches to select from
|-

| <keycap>Ctrl+Alt+N</keycap>
| Outline: Provide a list of all things that are happening in this file, e.g. class declarations and function definitions
|-

| <keycap>Ctrl+,</keycap>
| Jump to definition of a function if the cursor is currently on a function declaration
|-

| <keycap>Ctrl+.</keycap>
| Jump to declaration of a function or variable if the cursor is currently in a function definition
|-

| <keycap>Ctrl+Alt+PageDown</keycap>
| Jump to next function
|-

| <keycap>Ctrl+Alt+PageUp</keycap>
| Jump to previous function
|-

| <keycap>Ctrl+G</keycap>		
| Goto line

|-
!colspan="2"  style="background-color:#ffff99;" | Searching and replacing
|-

| <keycap>Ctrl+F</keycap>		
| Find
|-

| <keycap>F3</keycap>		
| Find next
|-

| <keycap>Ctrl+R</keycap>		
| Replace
|-

| <keycap>Ctrl+Alt+F</keycap>	
| Find-Replace in multiple files
|-

!colspan="2"  style="background-color:#ffff99;" | Other things
|-

| <keycap>Ctrl+_</keycap>		
| Collapse one level: remove this block from view, for example if you want to focus on the bigger picture within a function
|-

| <keycap>Ctrl++</keycap>		
| Expand one level: undo the collapsing
|-

| <keycap>Ctrl+D</keycap>		
| Comment out selected text or current line
|-

| <keycap>Ctrl+Shift+D</keycap>	
| Comment in selected text or current line
|-

| <keycap>Alt+Shift+D</keycap> 
| Document the current function. If the cursor is on a function or class declaration then hitting this key will create a doxygen-style comment pre-populated with a listing of all parameters, return values, etc.
|-

| <keycap>Ctrl+T</keycap>
| Transpose the current and the previous character
|-

| <keycap>Ctrl+K</keycap>
| Delete the current line (note: this is not just emacs' "delete from here to the end of the line")
|}

{{Prevnext2
| prevpage=Special:MyLanguage/KDevelop4/Manual/Sessions_and_projects | nextpage=Special:MyLanguage/KDevelop4/Manual/Code_generation_with_templates
| prevtext=Sessions and projects | nexttext=Code generation with templates
| index=Special:MyLanguage/KDevelop4/Manual | indextext=Back to menu
}}

[[Category:Разработка/ru]]