Стандартная библиотека шаблонов STL в языке программирования C++

Размещено на http://www.allbest.ru/

Федеральное государственное бюджетное образовательное учреждение высшего образования

Алтайский государственный педагогический университет

Институт информационных технологий и физико-математического образования

Курсовая работа:

«Стандартная библиотека шаблонов STL в языке программирования C++»

Выполнил:

Студент 4 курса

группы 3613з

Малетин Александр Владимирович

Барнаул 2020

Введение

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

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

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

Данная проблема особенно актуальна для программистов, так как им приходится писать много одинакового кода в разных проектах, что отнимает лишнее время. Поэтому, вопрос сокращения, затрачиваемого время, становится главным, как только начинаются крупные разработки, особенно ограниченные по срокам. Изучив теоретические пособия, становится понятным ответ - «Использовать шаблоны». В 20-м веке понадобилось несколько лет проб и ошибок, чтобы создать эти самые шаблоны.

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

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

Цели и задачи

1. Исследовать возможности STL для разработки

2. Сделать вывод подходит ли STL для junior и senior

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

Библиотека STL содержит пять основных видов компонентов:

-контейнер (container)

-итератор (iterator)

-алгоритм (algorithm)

-функциональный объект (function object)

-адаптер (adaptor)

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

Ядро библиотеки образуют три элемента: контейнеры, алгоритмы и итераторы. Контейнеры (containers) - это объекты, предназначенные для хранения набора элементов. Например, вектор, линейный список, множество. Ассоциативные контейнеры (associative containers) позволяют с помощью ключей получить быстрый доступ к хранящимся в них значениям. В каждом классе-контейнере определен набор функций для работы с ними. Например, контейнер "список" содержит функции для вставки, удаления и слияния элементов.

Контейнеры бывают двух видов:

- Последовательные контейнеры (или «контейнеры последовательности») -- это контейнерные классы, элементы которых находятся в последовательности. Их определяющей характеристикой является то, что вы можете добавить свой элемент в любое место контейнера. Наиболее распространенным примером последовательного контейнера является массив: при добавлении 4-х элементов в массив, эти элементы будут находиться (в массиве) в точно таком же порядке, в котором вы их добавили.

Начиная с C++11, STL содержит 6 контейнеров последовательности:

std::vector;

std::deque;

std::array;

std::list;

std::forward_list;

std::basic_string

Класс vector (или просто «вектор») -- это динамический массив, способный увеличиваться по мере необходимости для содержания всех своих элементов. Класс vector обеспечивает произвольный доступ к своим элементам через оператора индексации [], а также поддерживает добавление и удаление элементов.

`Пример использования vector'

#include <iostream>

#include <vector>

int main()

{

std::vector<int> vect;

for (int count=0; count < 5; ++count)

vect.push_back(10 - count); // добавляем числа в конец массива

for (int index=0; index < vect.size(); ++index)

std::cout << vect[index] << ' ';

std::cout << '\n';

Результат выполнения программы:

10 9 8 7 6

Класс deque (или просто «дек») -- это двусторонняя очередь, реализованная в виде динамического массива, который может расти с обоих концов.

`Пример использование deque'

#include <iostream>

#include <deque>

int main()

{

std::deque<int> deq;

for (int count=0; count < 4; ++count)

{

deq.push_back(count); // вставляем числа в конец массива

deq.push_front(10 - count); // вставляем числа в начало массива

}

for (int index=0; index < deq.size(); ++index)

std::cout << deq[index] << ' ';

std::cout << '\n';

}

Результат выполнения программы:

7 8 9 10 0 1 2 3

Представленный в C++11, std::array -- это фиксированный массив, который не распадается в указатель при передаче в функцию. std::array определяется в заголовочном файле array, внутри пространства имен std.

`Пример использования array'

#include <iostream>

#include <array>

Int main()

{

std::array<double, 4> myarray{ 8.0, 6.4, 4.3, 1.9 };

std::cout << “length: “ << myarray.size();

return 0;

}

Результат:

length: 4

List (или просто «список») -- это двусвязный список, каждый элемент которого содержит 2 указателя: один указывает на следующий элемент списка, а другой -- на предыдущий элемент списка. list предоставляет доступ только к началу и к концу списка -- произвольный доступ запрещен. Если вы хотите найти значение где-то в середине, то вы должны начать с одного конца и перебирать каждый элемент списка до тех пор, пока не найдете то, что ищете. Преимуществом двусвязного списка является то, что добавление элементов происходит очень быстро, если вы, конечно, знаете, куда хотите добавлять. Обычно для перебора элементов двусвязного списка используются итераторы.

#include <iostream>

#include <list>

#include <iterator>

using namespace std;

int main() {

list <int> mylist;

list <int> listmerge = {7, 8, 9};

for (int i = 0; i < 2; i++) {

for (int j = 1; j < 6; j++) {

mylist.push_back(i); }

}

copy (mylist.begin(), mylist.end(), ostream_iterator(cout, " "));

cout << endl;

mylist.insert(mylist.end(), 6);

copy (mylist.begin(), mylist.end(), ostream_iterator(cout, " "));

cout << endl;

mylist.unique();

list <int> :: iterator it;

for (it = mylist.begin(); it != mylist.end(); it++) {

cout << (*it) << " ";

}

mylist.merge(listmerge);

for (it = mylist.begin(); it != mylist.end(); it++) {

cout << (*it) << " ";

}

return 0;

}

Результат:

1 2 3 4 5 1 2 3 4 5

1 2 3 4 5 1 2 3 4 5 6

1 2 3 4 5 6

1 2 3 4 5 6 7 8 9

std::forward_list - это контейнер, который поддерживает быструю установку и удаление элементов из любого места в контейнере. Быстрый случайный доступ не поддерживается. Он реализован как односвязный список и по существу не имеет каких-либо накладных расходов по сравнению с его реализацией в C. По сравнению с std::list этот контейнер обеспечивает более экономичное пространство, когда двунаправленная итерация не нужна.

#include <forward_list>

#include <string>

#include <iostream>

template<typename T>

std::ostream& operator<<(std::ostream& s, const std::forward_list<T>& v) {

s.put('[');

char comma[3] = {'\0', ' ', '\0'};

for (const auto& e : v) {

s << comma << e;

comma[0] = ',';

}

return s << ']';

}

int main()

{

// c++11 initializer list syntax:

std::forward_list<std::string> words1 {"the", "frogurt", "is", "also", "cursed"};

std::cout << "words1: " << words1 << '\n';

// words2 == words1

std::forward_list<std::string> words2(words1.begin(), words1.end());

std::cout << "words2: " << words2 << '\n';

// words3 == words1

std::forward_list<std::string> words3(words1);

std::cout << "words3: " << words3 << '\n';

// words4 is {"Mo", "Mo", "Mo", "Mo", "Mo"}

std::forward_list<std::string> words4(5, "Mo");

std::cout << "words4: " << words4 << '\n';

}

Выход:

words1: [the, frogurt, is, also, cursed]

words2: [the, frogurt, is, also, cursed]

words3: [the, frogurt, is, also, cursed]

words4: [Mo, Mo, Mo, Mo, Mo]

std::basic_string - самый узнаваемый контейнер. У многих начало программирования было со знаменитой фразы `Hello, world'. Последовательность символов или просто строка. Именно это представляет собой контейнер basic_string.

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

Алгоритмы STL реализованы в виде глобальных функций, которые работают с использованием итераторов. Это означает, что каждый алгоритм нужно реализовать всего лишь один раз, и он будет работать со всеми контейнерами, которые предоставляют набор итераторов (включая и ваши собственные (пользовательские) контейнерные классы). Хотя это имеет огромный потенциал и предоставляет возможность быстро писать сложный код, у алгоритмов также есть и «тёмная сторона» -- некоторая комбинация алгоритмов и типов контейнеров может не работать/работать с плохой производительностью/вызывать бесконечные циклы, поэтому следует быть осторожным.

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

Алгоритмы min_element() и max_element() находят минимальный и максимальный элементы в контейнере, используя sort() и reverse()

#include <iostream>

#include <list>

#include <algorithm>

int main()

{

std::list<int> li;

for (int nCount=0; nCount < 5; ++nCount)

li.push_back(nCount);

std::list<int>::const_iterator it; // объявляем итератор

it = min_element(li.begin(), li.end());

std::cout << *it << ' ';

it = max_element(li.begin(), li.end());

std::cout << *it << ' ';

std::cout << '\n';

}

Результат выполнения программы:

0 и 4

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

#include <iostream>

#include <list>

#include <algorithm>

int main()

{

std::list<int> li;

for (int nCount=0; nCount < 5; ++nCount)

li.push_back(nCount);

std::list<int>::iterator it; // объявляем итератор

it = find(li.begin(), li.end(), 2); // ищем в списке число 2

li.insert(it, 7); // используем алгоритм list::insert() для добавления числа 7 перед числом 2

for (it = li.begin(); it != li.end(); ++it) // выводим с помощью цикла и итератора элементы списка

std::cout << *it << ' ';

std::cout << '\n';

}

Результат выполнения программы:

0 1 7 2 3 4

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

#include <iostream>

#include <vector>

#include <algorithm>

int main()

{

std::vector<int> vect;

vect.push_back(4);

vect.push_back(8);

vect.push_back(-3);

vect.push_back(3);

vect.push_back(-8);

vect.push_back(12);

vect.push_back(5);

std::sort(vect.begin(), vect.end()); // выполняем сортировку элементов вектора

std::vector<int>::const_iterator it; // объявляем итератор

for (it = vect.begin(); it != vect.end(); ++it) // выводим с помощью цикла и итератора элементы вектора

std::cout << *it << ' ';

std::cout << '\n';

std::reverse(vect.begin(), vect.end()); // сортируем элементы вектора в обратную сторону

for (it = vect.begin(); it != vect.end(); ++it) // выводим с помощью цикла и итератора элементы вектора

std::cout << *it << ' ';

std::cout << '\n';

}

Результат выполнения программы:

-8 -3 3 4 5 8 12

12 8 5 4 3 -3 -8

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

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

Функционал итераторов

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

Оператор “*” возвращает элемент, на который в данный момент указывает итератор.

Оператор “++” перемещает итератор к следующему элементу контейнера. Большинство итераторов также предоставляют оператор ?? для перехода к предыдущему элементу.

Операторы “==” и “!=” используются для определения того, указывают ли два итератора на один и тот же элемент или нет. Для сравнения значений, на которые указывают два итератора, нужно сначала разыменовать эти итераторы, а затем использовать оператор “==” или оператор “!=”.

Оператор “=” присваивает итератору новую позицию (обычно начальный или конечный элемент контейнера). Чтобы присвоить значение элемента, на который указывает итератор, другому объекту, нужно сначала разыменовать итератор, а затем использовать оператор “=”.

Существует 4 основных метода работы с операторами

1) метод begin() возвращает итератор, представляющий начальный элемент контейнера.

2) метод end() возвращает итератор, представляющий элемент, который находится после последнего элемента в контейнере. Может показаться странным, что метод end() не указывает на последний элемент контейнера, но это сделано в целях упрощения использования циклов: цикл перебирает элементы до тех пор, пока итератор не достигнет метода end(), и тогда уже всё - остановка процесса.

3) метод cbegin() возвращает константный (только для чтения) итератор, представляющий начальный элемент контейнера.

4) метод cend() возвращает константный (только для чтения) итератор, представляющий элемент, который находится после последнего элемента в контейнере.

Все контейнеры предоставляют, как минимум 2 типа итераторов:

a) container::iterator -- итератор для чтения/записи;

b) container::const_iterator -- итератор только для чтения.

Рассмотрим несколько примеров использования итераторов.

Итерация по вектору

Заполним вектор 6-ю числами и с помощью итераторов выведем значения вектора

#include <iostream>

#include <vector>

int main()

{

std::vector<int> myVector;

for (int count=0; count < 6; ++count)

myVector.push_back(count);

std::vector<int>::const_iterator it; // объявляем итератор только для чтения

it = myVector.begin(); // присваиваем ему начальный элемент вектора

while (it != myVector.end()) // пока итератор не достигнет последнего элемента

{

std::cout << *it << " "; // выводим значение элемента, на который указывает итератор

++it; // и переходим к следующему элементу

}

std::cout << '\n';

}

Результатом такой программы будет:

0 1 2 3 4 5

Итерация по списку

Выполнит такую же задачу, но со списком

#include <iostream>

#include <list>

int main()

{

std::list<int> myList;

for (int count=0; count < 5; ++count)

myList.push_back(count);

std::list<int>::const_iterator it; // объявляем итератор

it = myList.begin(); // присваиваем ему начальный элемент списка

while (it != myList.end()) // пока итератор не достигнет последнего элемента

{

std::cout << *it << " "; // выводим значение элемента, на который указывает итератор

++it; // и переходим к следующему элементу

}

std::cout << '\n';

}

Результат не меняется:

0 1 2 3 4 5

Код программ идентичен, однако их реализация значительно отличается.

Итерация по set-у

В следующей программе мы создадим set из 7 чисел и, используя итератор, выведем эти значения

#include <iostream>

#include <set>

int main()

{

std::set<int> mySet;

mySet.insert(7);

mySet.insert(4);

mySet.insert(-4);

mySet.insert(9);

mySet.insert(2);

mySet.insert(-12);

mySet.insert(35);

std::set<int>::const_iterator it; // объявляем итератор

it = mySet.begin(); // присваиваем ему начальный элемент set-а

while (it != mySet.end()) // пока итератор не достигнет последнего элемента

{

std::cout << *it << " "; // выводим значение элемента, на который указывает итератор

++it; // и переходим к следующему элементу

}

std::cout << '\n';

}

Результат выполнения программы:

-12 -4 2 4 7 9 35

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

Итерация по ассоциативному массиву

Данная итерация немного сложнее, контейнеры map и multimap принимают пары элементов (std::pair). Для создания пары используется функция make_pair(). std::pair позволяет получить доступ к элементу через первый и второй члены. В нашем ассоциативном массиве мы используем первый член в качестве «ключа», а второй в качестве «значения»

#include <iostream>

#include <map>

#include <string>

int main()

{

std::map<int, std::string> myMap;

myMap.insert(std::make_pair(4, "cat"));

myMap.insert(std::make_pair(6, "dog"));

myMap.insert(std::make_pair(1, "chicken"));

myMap.insert(std::make_pair(3, "lion"));

myMap.insert(std::make_pair(5, "spider"));

myMap.insert(std::make_pair(2, “dragon”));

std::map<int, std::string>::const_iterator it; // объявляем итератор

it = myMap.begin(); // присваиваем ему начальный элемент вектора

while (it != myMap.end()) // пока итератор не достигнет последнего элемента

{

std::cout << it->first << "=" << it->second << " "; // выводим значение элемента, на который указывает итератор

++it; // и переходим к следующему элементу

}

std::cout << '\n';

}

Результат выполнения программы:

1=chicken 2=dragon 3=lion 4=cat 5=spider 6=dog

Стоит обратить внимание на то, как легко перебирать элементы контейнеров с помощью итераторов. Подведём промежуточный итог, если вы - новичок, вам будет почти не сложно начать программирование на “c++”. Если вы - опытный разработчик, процесс написания для вас будет быстрым и упрощенным. Это однозначное преимущество.

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

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

Функциональный объект - представляет собой конструкцию, позволяющую использовать объект класса как функцию. В C++ для определения функтора достаточно описать класс, в котором переопределена операция ().

Рассмотрим пример того, как из объекта образуется функция

#include <iostream>

#include <vector>

using namespace std;

class summator : private vector<int> {

public:

summator(const vector<int>& ini) {

for (auto x : ini) this->push_back(x);

}

int operator()(bool even) {

int sum = 0;

auto i = begin();

if (even) i++;

while (i < end()) {

sum += *i++;

if (i == end()) break;

i++;

}

return sum;

}

};

int main(void) {

setlocale(LC_ALL, "rus");

summator sums(vector<int>({ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }));

cout << "Сумма чётных = " << sums(true) << endl

<< "Сумма нечётных = " << sums(false) << endl; }

Результат выполнения программы:

Сумма чётных = 30

Сумма нечётных = 25

Выгода функтора в том, что:

a) Его можно параметризовать при создании объекта, используя конструктор объекта с параметрами

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

Примером может послужить упрощенный целочисленный калькулятор

#include <iostream>

using namespace std;

class calculate {

char op;

public:

calculate( char op ) : op( op ) {}

int operator()( int op1, int op2 ) {

switch( op ) {

case '+': return op1 + op2;

case '-': return op1 - op2;

case '*': return op1 * op2;

case '/': return op1 / op2;

case '%': return op1 % op2;

case '^': {

int ret = op1;

while( op2-- > 1 ) ret *= op1;

return ret;

}

default:

cout << "неразрешённая операция" << endl;

return 0;

}

}

};

int main( int argc, char **argv, char **envp ) {

setlocale(LC_ALL, "rus");

char oper;

int op1, op2;

do {

cout << "выражение для вычисления (<op1><знак><op2>): " << flush;

cin >> op1 >> oper >> op2;

cout << op1 << ' ' << oper << ' ' << op2 << " = "

<< calculate( oper )( op1, op2 ) << endl;

} while( true );

return 0;

}

Здесь в строке cout << calculate( oper )( op1, op2 ) действия выполняются последовательно:

a) создаётся временный объект класса calculate конструктором с параметром oper;

b) для этого объекта выполняется метод () (функциональный вызов) с двумя параметрами;

c) операция, которая будет выполнена в этом функциональном вызове, зависит от того параметра oper, с которым был сконструирован объект;

d) функциональный вызов возвращает значение результата операции;

e) созданный временный объект, сразу же после этого разрушается (если бы у него был описан деструктор, то он бы вызывался в этой точке);

Максимальная полезность функторов раскрывается в алгоритмах STL.

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

Существует 3 вида адаптеров:

1) stack (стек) -- это контейнерный класс, элементы которого работают по принципу LIFO (англ. «Last In, First Out» = «Последним Пришёл, Первым Ушёл»), т.е. элементы добавляются (вносятся) в конец контейнера и удаляются (выталкиваются) оттуда же (из конца контейнера). Обычно в стеках используется deque в качестве последовательного контейнера по умолчанию (что немного странно, поскольку vector был бы более подходящим вариантом), но вы также можете использовать vector или list.

#include <iostream>

#include <vector>

#include <stack>

#include <string>

using namespace std;

int main(int argc, char *argv[]) {

setlocale(LC_ALL, "rus");

stack<string> st;

stack<string, vector<string> > vst(

vector<string>({ "строка 1", "строка 2" })

);

vst.push("последняя строка");

while (!vst.empty()) {

cout << vst.top() << " : в стеке строк " << vst.size() << endl;

vst.pop();

}

cout << "стек " << (vst.empty() ? "" : "не ") << "пуст" << endl;

}

2) queue (очередь) -- это контейнерный класс, элементы которого работают по принципу FIFO (англ. «First In, First Out» = «Первым Пришёл, Первым Ушёл»), т.е. элементы добавляются (вносятся) в конец контейнера, но удаляются (выталкиваются) из начала контейнера. По умолчанию в очереди используется deque в качестве последовательного контейнера, но также может использоваться и list.

#include <iostream>

#include <queue>

template <class Container>

class Adapter : public Container

{

public:

typedef typename Container::container_type container_type;

container_type& get_container()

{

return this->c;

}

};

int main()

{

typedef std::queue<int> C;

typedef Adapter<C> Container;

Container adapter;

for (int i = 0; i < 10; ++i)

{

adapter.push(i);

}

Container::container_type& c = adapter.get_container();

for (Container::container_type::iterator it = c.begin(); it != c.end(); ++it)

{

std::cout << *it << " ";

}

return 0;

}

3) priority_queue (очередь с приоритетом) -- это тип очереди, в которой все элементы отсортированы (с помощью оператора сравнения <). При добавлении элемента, он автоматически сортируется. Элемент с наивысшим приоритетом (самый большой элемент) находится в самом начале очереди с приоритетом, также, как и удаление элементов выполняется с самого начала очереди с приоритетом.

#include <iostream>

#include <algorithm>

#include <queue>

#include <vector>

int main()

{

std::priority_queue<int> cont;

std::vector<int> copy;

for(int i = 0; i <= 10; ++i)

cont.push(i);

for(int i = 0; i <= 10; ++i)

{

std::cout << cont.top() << " ";

copy.push_back(cont.top());

cont.pop();

}

std::find_if(copy.begin(), copy.end(), /* условие*/);

return 0;

}

Заключение

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

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

Из этого я могу сделать субъективный вывод, что изучение языка программирования c++ можно начинать одновременно с изучением stl. Так же, stl подойдет для крупных разработок.

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

библиотека итератор алгоритм адаптер

Список используемой литературы

1. Михеева Е.В. Практикум по информатике: учеб. пособие. - М., 2004.

2. Симанович С.В. Информатика: Базовый курс. - СПб., 2000.

3. Каталог образовательных ресурсов сети Интернет

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

5. - IT-блог

6. Образовательный ресурс сети Интернет по теме «Языки программирования»

Размещено на Allbest.ru