Программирование на языке С++

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Оглавление

I. Введение

II. Основная часть

1. История возникновения языка программирования С++ …………………..4

2. Эффективность и устройство …………………………………………….5

3. Структура программы в C++ ………………………………………………..7

4. Парадигмы программирования …………………………………………….10

1. Процедурное программирование …………………… …………………..11

2. Модульное программирование …………………………………………...12

3. Абстракция данных ……………………………………………………….13

III. Заключение

IV. Список литературы

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 Введение

 Важной вехой в развитии программирования явилось создание и широкое распространение языка С++. Этот язык, сохранив средства ставшего общепризнанным стандартом для написания системных и прикладных программ языка С (процедурно-ориентированный язык), ввел в практику программирования возможности нового технологического подхода к разработке программного обеспечения, получившего название “объектно-ориентированное программирование”. Внедрение в практику программирования объектно-ориентированной парадигмы дает развитие новых областей информатики, значительное повышение уровня технологичности создаваемых программных средств, сокращение затрат на разработку и сопровождение программ, их повторное использование, вовлечение в процесс расширения интеллектуальных возможностей ЭВМ. Объектный подход информационного моделирования предметных областей все более успешно применяется в качестве основы для структуризации их информационных отражений и, в частности, баз знаний.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

История возникновения языка программирования С++

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

Язык программирования C++ широко используется для разработки программного обеспечения. А именно, создание разнообразных прикладных программ, разработка операционных систем, драйверов устройств, а также видео игр и многое другое. Существует несколько реализаций языка программирования C++ — как бесплатных, так и коммерческих. Их производят проекты: GNU, Microsoft и Embarcadero (Borland). Проект GNU  — проект разработки свободного программного обеспечения (СПО). 

Язык программирования С++ был создан в начале 1980-х годов, его создатель сотрудник фирмы Bell Laboratories — Бьёрн Страуструп. Он придумал ряд усовершенствований к языку программирования C, для собственных нужд. Т. е. изначально не планировалось создания языка программирования С++.  Ранние версии языка С++, известные под именем »Cи с классами», начали появляться с 1980 года. Язык C, будучи базовым языком системы UNIX, на которой работали компьютеры фирмы Bell, является быстрым, многофункциональным и переносимым. Страуструп добавил к нему возможность работы с классами и объектами, тем самым зародил предпосылки нового, основанного на синтаксисе С, языка программирования. Синтаксис C++ был основан на синтаксисе C, так как Бьёрн Страуструп стремился сохранить совместимость с языком C. В 1983 году произошло переименование языка из »Cи с классами»в «язык программирования C++». В него были добавлены новые возможности: виртуальные функции, перегрузка функций и операторов, ссылки, константы и многое другое. Его первый коммерческий выпуск состоялся в октябре 1985 года. Язык программирования C++ является свободным, то есть никто не обладает на него правами.  

 

 

 

 

 

 

 

Эффективность и устройство

    Развитие языка  С++ происходило на базе языка  С, и, за небольшим исключением,  С был сохранен в качестве  подмножества C++. Базовый язык С  был спроектирован таким образом,  что имеется очень тесная связь  между типами, операциями, операторами и объектами, с которыми непосредственно работает машина, т.е. числами, символами и адресами. За исключением операций new, delete и throw, а также проверяемого блока, для выполнения операторов и выражений С++ не требуется скрытой динамической аппаратной или программной поддержки.

    Первоначально  язык С задумывался как конкурент  ассемблера, способный вытеснить  его из основных и наиболее  требовательных к ресурсам задач  системного программирования. В  проекте С++ были приняты меры, чтобы успехи С в этой области не оказались под угрозой. Различие между двумя языками прежде все состоит в степени внимания, уделяемого типам и структурам. Язык С выразителен и в то же время снисходителен по отношению к типам. Язык С++ еще более выразителен, но такой выразительности можно достичь лишь тогда, когда типам уделяют большое внимание. Когда типы объектов известны, транслятор правильно распознает такие выражения, в которых иначе программисту пришлось бы записывать операции с утомительными подробностями.  Кроме того, знание типов позволяет транслятору обнаруживать такие ошибки, которые в противном случае были бы выявлены только при тестировании.  Отметим, что само по себе использование строгой типизации языка для контроля параметров функции, защиты данных от незаконного доступа, определения новых типов и операций не влечет дополнительных расходов памяти и увеличения времени выполнения программы.

    В проекте  С++ особое внимание уделяется  структурированию программы. Это  вызвано увеличением размеров  программ со времени появления С. Небольшую программу (скажем, не более 1000 строк) можно заставить из упрямства работать, нарушая все правила хорошего стиля программирования. Однако, действуя так, человек уже не сможет справиться с большой программой. Если у вашей программы в 10 000 строк плохая структура, то вы обнаружите, что новые ошибки появляются в ней так же быстро, как удаляются старые. С++ создавался с целью, чтобы большую программу можно было структурировать таким образом, чтобы одному человеку не пришлось работать с текстом в 25000 строк. В настоящее время можно считать, что эта цель полностью достигнута.

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

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

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

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

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

 

 

 

 

 

 

 

 

 

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

Прежде чем  приступить к написанию программ, необходимо изучить структуру программ на языке программирования С++. Своими словами, структура программ  это разметка рабочей области (области кода) с целью чёткого определения основных блоков программ и синтаксиса. Структура программ несколько отличается в зависимости от среды программирования. Мы ориентируемся на MVS2010, и по этому примеры программ будут показаны именно для MVS2010. Если вы используете другую IDE, то вам не составит труда перенести код из MVS2010 в другие среды разработки, и вы поймете со временем, как это сделать.

Структура программ для Microsoft Visual Studio.

1 2 3 4 5 6

// struct_program.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" //здесь подключаем все необходимые препроцессорные директивы void main() { // начало главной функции с именем main //здесь будет находится ваш программный код }

В строке 1 говорится  о точке входа для консольного  приложения, это значит, что данную программу можно запустить через  командную строку Windows указав имя  программы, к примеру, такое struct_program.cpp. Строка 1 является однострочным комментарием, так как начинается с символов //, подробнее о комментариях будет рассказано в следующей статье. В строке 2 подключен заголовочный файл "stdafx.h". Данный файл похож на контейнер, так как в нем подключены основные препроцессорные директивы (те, что подключил компилятор, при создании консольного приложения), тут же могут быть подключены и вспомогательные (подключенные программистом).

include — директива препроцессора, т. е. сообщение препроцессору. Строки, начинающиеся с символа # обрабатываются препроцессором до компиляции программы.

Препроцессорные директивы также можно подключать и в строках, начиная после  записи #include "stdafx.h" до начала главной функции. Причём такой способ подключения библиотек является основным, а использование "stdafx.h" — это дополнительная возможность подключения заголовочных файлов, которая есть только в MVS. С 4-й по 6-ю строки объявлена функция main. Строка 4 – это заголовок функции, который состоит из типа возвращаемых данных (в данном случае void), этой функцией, и имени функции, а также круглых скобок, в которых объявляются параметры функции.

void — тип данных не имеющий значения, т.е он не может хранить никакой информации.

Между фигурными  скобочками размещается основной программный  код, называемый еще телом функции. Это самая простая структура программы. Данная структура написана в Microsoft Visual Studio 2010 (MVS2010). Все выше сказанное остается справедливым и для других компиляторов, кроме строки 2. Контейнера "stdafx.h" нигде кроме MVS нет.

Структура программы для C++ Builder.

При создании консольного  приложения мастер создания проектов создает автоматически следующий  код:

1 2 3 4 5 6

//препроцессорная директива, автоматически подключённая мастером создания  проектов #include <vcl.h> int main() { return 0; }

Мы видим, что  у функции поменялся тип данных, место void написано int. Это говорит о том что по завершении работы функция вернет какое-то целочисленное значение, в нашем случае 0. Целочисленное потому, что int – это тип данных для целых чисел, таких как 4, 5, 6, 456, 233 и т. д.

Главное помнить, что если тип возвращаемых данных у функции main - это int или любой другой, кроме void, то следует писать строку типа этой: return <возвращаемое значение>;

В строке 2 подключена библиотека vcl.h – её автоматически подключает мастер создания приложений, поэтому удалять её не следует, иначе проект не будет рабочим.

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

Например:

1 2 3 4

int main(int argc, char* argv[]) { return 0; }

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

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

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

Пример структуры  программы MVS2010 с подключенными библиотеками.

1 2 3 4 5 6

#include "stdafx.h" #include <iostream> using namespace std; void main() { }

 

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

Синтаксис подключения  заголовочных файлов:

#include <имя заголовочного файла>

Более старые заголовочные файлы подключаются так (этот стиль  подключения библиотек унаследован  у языка программирования C):

#include <имя заголовочного файла.h>

Различие состоит  в том, что после имени ставится расширение .h.

Язык программирования С++ является регистрозависимым. Например: 
Return 0; – не правильно, будет ошибка компиляции. 
return 0; – правильно!!!

 

 

 

 

 

Парадигмы программирования

Объектно-ориентированное  программирование - это метод программирования, способ написания"хороших" программ для множества задач. Если этот термин имеет какой-то смысл, то он должен

подразумевать: такой язык программирования, который  предоставляет хорошие возможности  для объектно-ориентированного стиля программирования. Здесь следует указать на важные различия. Говорят, что язык поддерживает некоторый стиль программирования, если в нем есть такие возможности, которые делают программирование в этом

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

Действительно, можно писать структурные программы  на Фортране и объектно-ориентированные программы на С, но это будет пустой тратой сил, поскольку данные языки не поддерживают указанных стилей программирования.

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

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

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

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

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

[2] Для решения  определенной задачи должна быть  возможность использовать сочетания

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

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

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

возникло дополнительных расходов.

[5] Пользователю  достаточно знать только то  множество конструкций, которое  непосредственно используется в его программе.

Первое требование апеллирует к логике и эстетическому  вкусу. Два следующих выражают принцип минимальности. Два последних можно иначе сформулировать так: "то, чего вы не знаете, не сможет нанести вам вреда".

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

пользователей.

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

 

Процедурное программирование

Первоначальной (и, возможно, наиболее используемой) парадигмой программирования было:

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

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

передачи параметров, о том, как различать параметры  разных типов, о различных видах  функций процедуры, подпрограммы, макрокоманды, ...) и т.д. Первым процедурным языком был Фортран, а Агол60, Алгол68, Паскаль и С продолжили это направление.

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

double sqrt ( double arg )

{

// программа  для вычисления квадратного корня

}

void some_function ()

{

double root = sqrt ( 2 );

// ..}

Двойная наклонная черта // начинает комментарий, который продолжается до конца строки. При такой организации программы функции вносят определенный порядок в хаос различных алгоритмов.

 

Модульное программирование

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

Парадигма программирования приобрела вид:

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

программирования. Теперь метод написания "хороших" процедур применяется для отдельных  процедур модуля. Типичный пример модуля - определение стека. Здесь необходимо решить такие задачи:

[1] Предоставить  пользователю интерфейс для стека  (например, функции push () и pop ()).

[2] Гарантировать,  что представление стека (например, в виде массива элементов) будет  доступно

лишь через  интерфейс пользователя.

[3] Обеспечивать  инициализацию стека перед первым  его использованием.

Язык Модула-2 прямо поддерживает эту парадигму, тогда как С только допускает такой стиль. Ниже представлен на С возможный внешний интерфейс модуля, реализующего стек: 

 // описание интерфейса для модуля, реализующего стек символов:

void push ( char );

char pop ();

const int stack_size = 100;

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

#include "stack.h"                 // используем интерфейс стека

static char v [ stack_size ]; // ``static'' означает локальный

                                                    // в данном файле/модуле,    стек вначале пуст

static char * p = v;                    

void push ( char c ) {              //проверить на переполнение и поместить в стек 

} char pop ()   {

                                                     //проверить, не пуст ли стек, и считать из него

} 

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

 

#include "stack.h"                                    // используем интерфейс стека

void some_function ()

{

push ( 'c' );

char c = pop ();

if ( c != 'c' ) error ( "невозможно" );

}

 

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

 

Абстракция  данных

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

class stack_id { /* ... */ };             // stack_id только тип

                                                             // никакой информации о стеках

                                                             // здесь не содержится

stack_id create_stack ( int size ); // создать стек и возвратить

// его идентификатор

void push ( stack_id, char );

char pop ( stack_id );

destroy_stack ( stack_id ); // уничтожение стека

Конечно такое  решение намного лучше, чем хаос, свойственный традиционным, неструктурированным решениям, но моделируемые таким способом типы совершенно очевидно отличаются от "настоящих",

встроенных. Каждый управляющий типом модуль должен определять свой собственный алгоритм

создания "переменных" этого типа. Не существует универсальных  правил присваивания идентификаторов, обозначающих объекты такого типа. У "переменных" таких типов не существует имен, которые были бы известны транслятору или другим системным программам, и эти "переменные"

не подчиняются  обычным правилам областей видимости  и передачи параметров.

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

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

сможет отловить глупые, очевидные ошибки, вроде  тех, что допущены в приведенной  ниже функции:

void f ()

{

stack_id s1;

stack_id s2;

s1 = create_stack ( 200 );

                                                                    // ошибка: забыли создать s2

push ( s1,'a' );

char c1 = pop ( s1 );

destroy_stack ( s2 );                            // неприятная ошибка

                                                                    // ошибка: забыли уничтожить s1

s1 = s2;                                                      // это присваивание является по сути

                                                                    // присваиванием указателей,

                                                                   // но здесь s2 исп-ся после уничтожения

}

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

В языках Ада, Clu, С++ и подобных им эта трудность  преодолевается благодаря тому, что  пользователю разрешается определять свои типы, которые трактуются в языке практически так же, как встроенные. Такие

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

конкретным  представлением действительно абстрактных сущностей. Как определить "более абстрактные"  типы, показано в $$4.6. Парадигму же программирования можно выразить теперь так:

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

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

Арифметические  типы, подобные типам рациональных и комплексных чисел, являются типичными примерами пользовательских типов:

class complex

{

double re, im;

public:

complex(double r, double i) { re=r; im=i; }

complex(double r)                                                       // преобразование float->complex

{ re=r; im=0; }

friend complex operator+(complex, complex);

friend complex operator-(complex, complex);  // вычитание

friend complex operator-(complex) // унарный минус

friend complex operator*(complex, complex);

friend complex operator/(complex, complex);

// ...

};

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 Заключение

 

    Как было обещано в первом  издании книги «Бьерн Страуструп. Язык программирования С++ », запросы  пользователей определили развитие  С++. Его направлял опыт широкого  круга пользователей, работающих в разных областях программирования.  За шесть лет, отделяющих нас от первого издания описания С++, число пользователей возросло в сотни раз. За эти годы были усвоены многие уроки, были предложены и подтвердили практикой свое право на существование различные приемы программирования.