http://mit.spbau.ru/sewiki/api.php?action=feedcontributions&feedformat=atom&user=KatepolSEWiki - Вклад участника [ru]2026-04-06T09:56:32ZВклад участникаMediaWiki 1.26.2http://mit.spbau.ru/sewiki/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D1%86%D0%B0:Katepol&diff=377Участница:Katepol2011-09-17T08:26:33Z<p>Katepol: /* Екатерина Полищук */</p>
<hr />
<div>== Екатерина Полищук ==<br />
[mailto:katepol14@gmail.com katepol14@gmail.com]<br />
<br />
[[Файл:Kate1.jpg|200px|right]]<br />
<br />
''Образование''<br />
<br />
* 2006-2010 гг Санкт-Петербургский Государственный Политехнический Университет, Факультет Технической Кибренетики, кафедра Информационных и Управляющих Систем.<br />
<br />
''Опыт работы''<br />
<br />
* 08/2009-12/2009 [http://www.totalobjects.co.uk/ Total Objects]<br />
.NET Developer.<br />
* 07/2011-today [http://www.jetbrains.com/ JetBrains]<br />
Java Developer. Занимаюсь разработкой [http://www.gnu.org/software/emacs/ Emacs] плагина для [http://www.jetbrains.com/idea/ Intellij Idea]. <br />
<br />
''Проекты''<br />
<br />
* [http://code.google.com/p/practice2010/ Naive Bayesian Classifier] - simple web pages classifier.<br />
* [https://github.com/SmartHub/ExcursionOrganizer Excursion Organizer] - web service for excursion organization in St. Petersburg. Командный проект совместно со [http://mit.spbau.ru/sewiki/index.php/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Svetlana_Marchenko Светой Марченко], [http://mit.spbau.ru/sewiki/index.php/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Aleksandr.kartashov Сашей Карташовым], [http://mit.spbau.ru/sewiki/index.php/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Alexey.Gurevich Лешей Гуревичем], и Пашей Синай.<br />
* [https://github.com/katepol/PanoramaRecognition Panorama Recognition] - recognition of panorama parts using OpenCV.</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D1%86%D0%B0:Katepol&diff=376Участница:Katepol2011-09-17T08:03:09Z<p>Katepol: /* Екатерина Полищук */</p>
<hr />
<div>== Екатерина Полищук ==<br />
[mailto:katepol14@gmail.com katepol14@gmail.com]<br />
<br />
[[Файл:Kate1.jpg|200px|right]]<br />
<br />
Образование:<br />
<br />
* 2006-2010 гг Санкт-Петербургский Государственный Политехнический Университет, Факультет Технической Кибренетики, кафедра Информационных и Управляющих Систем.<br />
<br />
Опыт работы:<br />
<br />
* 08/2009-12/2009 [http://www.totalobjects.co.uk/ Total Objects]<br />
.NET Developer<br />
* 07/2011-today [http://www.jetbrains.com/ JetBrains]<br />
Java Developer. Занимаюсь разработкой [http://www.gnu.org/software/emacs/ Emacs] плагина для [http://www.jetbrains.com/idea/ Intellij Idea]. <br />
<br />
Готовые проекты можно найти здесь:<br />
<br />
* [http://code.google.com/p/practice2010/ Naive Bayesian Classifier] - simple web pages classifier.<br />
* [https://github.com/katepol/PanoramaRecognition Panorama Recognition] - recognition of panorama parts using OpenCV.</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D1%86%D0%B0:Katepol&diff=375Участница:Katepol2011-09-17T08:00:26Z<p>Katepol: </p>
<hr />
<div>== Екатерина Полищук ==<br />
[mailto:katepol14@gmail.com katepol14@gmail.com]<br />
<br />
[[Файл:Kate1.jpg|200px|right]]<br />
<br />
Образование:<br />
<br />
* 2006-2010 гг Санкт-Петербургский Государственный Политехнический Университет, Факультет Технической Кибренетики, кафедра Информационных и Управляющих Систем.<br />
<br />
Опыт работы:<br />
<br />
* 08/2009-12/2009 [www.totalobjects.co.uk Total Objects]<br />
.NET Developer<br />
* 07/2011-today [http://www.jetbrains.com/ JetBrains]<br />
Java Developer. Занимаюсь разработкой [http://www.gnu.org/software/emacs/ Emacs] плагина для [http://www.jetbrains.com/idea/ Intellij Idea]. <br />
<br />
Готовые проекты можно найти здесь:<br />
<br />
* [http://code.google.com/p/practice2010/ Naive Bayesian Classifier] - simple web pages classifier.<br />
* [https://github.com/katepol/PanoramaRecognition Panorama Recognition] - recognition of panorama parts using OpenCV.</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%9D%D0%B0%D0%BF%D0%BE%D0%BC%D0%B8%D0%BD%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%BE_inline_%D0%B8_static._%D0%A1%D0%B8%D0%BD%D0%B3%D0%BB%D1%82%D0%BE%D0%BD.&diff=201Напоминание про inline и static. Синглтон.2011-05-02T10:09:57Z<p>Katepol: /* Синглтон */</p>
<hr />
<div>==Inline==<br />
Рассмотрим некоторую inline функцию:<br />
<source lang="cpp"><br />
inline void f() {}<br />
</source><br />
'''Где ее разместить: в cpp или в header'e?'''<br />
<br />
1) При размещении любой функции в заголовочном файле, если данный header включен в несколько файлов вашего проекта, проект упадет при линковке, если ваша функция не inline.<br />
<br />
2) Если вы создаете inline функцию, то ее нужно размещать в header'e, так как<br />
* определение функции должно быть видно из того места в коде, где она используется;<br />
* если разделить определение и тело inline функции, то ее можно будет использовать только в том cpp файле, в котором находится ее тело.<br />
<br />
Если определить метод внутри класса, то он автоматически становится inline:<br />
<source lang="cpp"><br />
class T {<br />
int size_;<br />
public:<br />
size_t getSize() const { // inline!<br />
return size_;<br />
}<br />
};<br />
</source> <br />
<br />
Шаблонные функции - тоже inline, по очевидной причине: шаблонная функция должна быть определена к моменту вызова (при инстанциировании).<br />
<source lang="cpp"><br />
template <typename T><br />
void swap (T & a, T & b) {<br />
...<br />
}<br />
</source><br />
<br />
==Глобальные переменные==<br />
Что мы о них знаем? Что их не нужно использовать :), так как невозможно спрогнозировать, что лежит в этой переменной.<br />
Если у нас все же есть глобальная переменная и она определена в нескольких cpp файлах, то наша программа упадет при линковке. Избежать этого позволяет ключевое слово '''extern''':<br />
<source lang="cpp"><br />
// 1.cpp<br />
int i = 0;<br />
<br />
// 2.cpp<br />
extern int i; // extern указывает на то, что i определена где-то снаружи<br />
</source><br />
<br />
На самом деле, перед любым объявлением функции автоматически ставится extern (можно явно писать, ошибки не будет).<br />
<br />
==Статические переменные==<br />
Если уж очень нужны глобальные переменные, лучше использовать статические переменные. Ключевое слово '''static''' обеспечивает защиту от перекрытия имен. Static может использоваться в 5 контекстах:<br />
<br />
'''1. Статические глобальные переменные'''<br />
<source lang="cpp"><br />
// 1.cpp<br />
static int i = 0;<br />
</source><br />
Такое объявление переменной делает ее глобальной в пределах одного cpp файла, в данном случае - 1.cpp.<br />
Если объявить статическую переменную i в заголовочном файле, то в каждом файле, в который будет подключен этот header, будет по одной собственной i.<br />
<br />
''Замечание: типы линковки.''<br />
<br />
Линковка бывает:<br />
* external - функции и переменные между модулями;<br />
* internal - внутри одного модуля. Пример использования - счетчик открытых файлов.<br />
<br />
'''2. Статические функции'''<br />
<br />
Внутренняя линковка (internal). <br />
<br />
Можно создавать разные функции с одинаковыми сигнатурами. Так как они определяются во время вызова, то могут и встроиться :).<br />
<br />
Пример: можно в каждом cpp файле создать свою функцию static void test(). Напомню, что ключевое слово static защищает от перекрытия имен.<br />
<br />
'''3. Статические локальные переменные'''<br />
<br />
Рассмотрим следующую функцию:<br />
<source lang="cpp"><br />
void print (double x) {<br />
static int i = 0;<br />
std::cout << (++i) << x << std::endl;<br />
}<br />
</source><br />
Переменная i хранится не хранится на стеке. По сути, она является глобальной переменной, но ее областью видимости является только функция print.<br />
<br />
Статические локальные переменные уничтожаются при выходе из main().<br />
<br />
Если сделать функцию print статической и вставить в несколько cpp файлов, то у каждого print будет свой счетчик i и своя реализация. А если сделать ее inline, то 1 общая реализация.<br />
<br />
Рассмотрим еще один пример:<br />
<source lang="cpp"><br />
1. void print (char const * fn, double x) {<br />
2. static int i = 0;<br />
3. static ofstream file(fn) = q(); // q() - некоторая функция<br />
4. file << (++i) << x << endl;<br />
5. }<br />
</source><br />
* Если бы переменная ofstream file не была статической, то при каждом входе в print файл открывался бы заново.<br />
* Т.к. file - статическая, то при каждом входе в print, кроме первого раза, строка 3 игнорируется: как инициализация переменной file, так и =q(). <br />
<br />
Применение: храниение локальных данных функций.<br />
<source lang="cpp"><br />
char * g() {<br />
static char m[100];<br />
return m; // имеет смысл, т.к. m static => хранится не на стеке<br />
}<br />
</source><br />
<br />
Статические переменные так же можно возвращать по ссылке:<br />
<source lang="cpp"><br />
string & g() {<br />
static string s;<br />
return s;<br />
}<br />
</source><br />
<br />
''Недостаток использования статических локальных переменных:''<br />
* невозможно проследить, кто и когда их изменяет. В многопоточных приложениях от них вообще стоит отказаться :)<br />
<br />
Тем не менее, это эффективнее, чем выделение динамической памяти.<br />
<br />
'''4. Статические члены данных класса '''<br />
Вышесказанное относилось как к С++, так и к С. Этот и следующий параграфы, очевидно, относятся только к С++.<br />
<br />
Рассмотрим пример:<br />
<source lang="cpp"><br />
class Array {<br />
private:<br />
static int count_; // объявление статического члена данных класса. Он не хранится в объекте класса.<br />
static string name_; // Статические члены данных класса подобны глобальным переменным внутри класса. <br />
};<br />
</source><br />
В данном примере статические члены данных объявлены private, поэтому изменять их можно только из внутренних методов класса или "друзьями" (friend).<br />
Для того, чтобы проинициализировать статические члены данных, их нужно определить в каком-нибудь срр-файле, чтобы выделилась память:<br />
<source lang="cpp"><br />
Array::count_ = 0;<br />
string Array::name_("Array");<br />
</source><br />
<br />
Определить статическое поле внутри класса можно тогда и только тогда, когда оно целочисленное и константное (т.к. в момент компиляции работа только с целочисленными типами):<br />
<source lang="cpp"><br />
static int const dimension = 10;<br />
</source><br />
<br />
''Примеры использования:''<br />
* подсчет количества экземпляров класса;<br />
* хранение информации, общей для всех экземпляров класса;<br />
* хранение списка объектов класса.<br />
<br />
<br />
'''5. Статические методы класса'''<br />
<br />
Не зависят от объектов класса. Рассмотрим пример:<br />
<source lang="cpp"><br />
class Array {<br />
private:<br />
static string name_;<br />
public:<br />
static string getName() { // rem. getName() - inline, т.к. определена внутри класса <br />
return name_;<br />
}<br />
};<br />
<br />
int main() {<br />
Array a;<br />
a.getName(); // cинтаксически возможно, но логически неправильно<br />
<br />
Array::getName(); // правильно<br />
}<br />
</source><br />
<br />
Метод getName() не имеет доступа к членам класса, но если передать в нее ссылку на объект класса, то из getName() можно будет изменять private поля.<br />
<br />
Невозможно объявить статический метод класса константным, так как const запрещает изменять поля объекта, а в static методы this не передается:<br />
<source lang="cpp"><br />
static void f() const; // ошибка!<br />
</source><br />
<br />
'''template и static'''<br />
<br />
* Поведение статических локальных переменных в шаблонах функций: для каждого инстанса функции будет своя статическая локальная переменная.<br />
* Static в шаблонах классов:<br />
<source lang="cpp"><br />
template <class T> <br />
class Array {};<br />
</source><br />
Для каждого инстанса класса будут свои статические поля и методы. <br />
<br />
Но как определить снаружи статическую переменную шаблонного класса?<br />
<br />
1 вариант:<br />
<source lang="cpp"><br />
// array.h<br />
template <class T><br />
class Array <br />
{<br />
static double q;<br />
public:<br />
Array();<br />
static double getQ() { <br />
return q;<br />
}<br />
};<br />
<br />
template <class T><br />
double Array<T>::q = 1.5;<br />
<br />
// main.cpp<br />
#include <iostream><br />
#include "array.h"<br />
<br />
int main()<br />
{<br />
std::cout << Array<int>::getQ() << std::endl;<br />
std::cout << Array<float>::getQ() << std::endl;<br />
return 0;<br />
}<br />
<br />
//output: 1.5, 1.5<br />
</source><br />
<br />
2 вариант:<br />
<source lang="cpp"><br />
// array.h<br />
template <class T><br />
class Array <br />
{<br />
static double q;<br />
public:<br />
Array();<br />
static double getQ() { <br />
return q;<br />
}<br />
};<br />
<br />
//array.cpp<br />
#include "array.h"<br />
<br />
template <><br />
double Array<int>::q = 1.5;<br />
template <><br />
double Array<float>::q = 2.6;<br />
<br />
// main.cpp<br />
#include <iostream><br />
#include "array.h"<br />
<br />
int main()<br />
{<br />
std::cout << Array<int>::getQ() << std::endl;<br />
std::cout << Array<float>::getQ() << std::endl;<br />
return 0;<br />
}<br />
<br />
// output: 1.5, 2.6<br />
</source><br />
<br />
Rem. Вообще, шаблоны не очень дружат со static параметром шаблона: не может быть указателя на статическую функцию.<br />
<br />
==Синглтон==<br />
<br />
def. Синглтон - это объект, который в момент исполнения существует в единственном экземпляре.<br />
<br />
Пример:<br />
<source lang="cpp"><br />
// array.h<br />
struct Array {<br />
private:<br />
// все конструкторы<br />
static Array * inst_;<br />
public:<br />
static Array & getInstance() {<br />
if (inst_ == 0)<br />
inst_ = new Array();<br />
return *inst_;<br />
}<br />
};<br />
<br />
// array.cpp<br />
Array * Array::inst_ = 0;<br />
</source></div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%9D%D0%B0%D0%BF%D0%BE%D0%BC%D0%B8%D0%BD%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%BE_inline_%D0%B8_static._%D0%A1%D0%B8%D0%BD%D0%B3%D0%BB%D1%82%D0%BE%D0%BD.&diff=200Напоминание про inline и static. Синглтон.2011-05-02T09:48:34Z<p>Katepol: /* Статические переменные */</p>
<hr />
<div>==Inline==<br />
Рассмотрим некоторую inline функцию:<br />
<source lang="cpp"><br />
inline void f() {}<br />
</source><br />
'''Где ее разместить: в cpp или в header'e?'''<br />
<br />
1) При размещении любой функции в заголовочном файле, если данный header включен в несколько файлов вашего проекта, проект упадет при линковке, если ваша функция не inline.<br />
<br />
2) Если вы создаете inline функцию, то ее нужно размещать в header'e, так как<br />
* определение функции должно быть видно из того места в коде, где она используется;<br />
* если разделить определение и тело inline функции, то ее можно будет использовать только в том cpp файле, в котором находится ее тело.<br />
<br />
Если определить метод внутри класса, то он автоматически становится inline:<br />
<source lang="cpp"><br />
class T {<br />
int size_;<br />
public:<br />
size_t getSize() const { // inline!<br />
return size_;<br />
}<br />
};<br />
</source> <br />
<br />
Шаблонные функции - тоже inline, по очевидной причине: шаблонная функция должна быть определена к моменту вызова (при инстанциировании).<br />
<source lang="cpp"><br />
template <typename T><br />
void swap (T & a, T & b) {<br />
...<br />
}<br />
</source><br />
<br />
==Глобальные переменные==<br />
Что мы о них знаем? Что их не нужно использовать :), так как невозможно спрогнозировать, что лежит в этой переменной.<br />
Если у нас все же есть глобальная переменная и она определена в нескольких cpp файлах, то наша программа упадет при линковке. Избежать этого позволяет ключевое слово '''extern''':<br />
<source lang="cpp"><br />
// 1.cpp<br />
int i = 0;<br />
<br />
// 2.cpp<br />
extern int i; // extern указывает на то, что i определена где-то снаружи<br />
</source><br />
<br />
На самом деле, перед любым объявлением функции автоматически ставится extern (можно явно писать, ошибки не будет).<br />
<br />
==Статические переменные==<br />
Если уж очень нужны глобальные переменные, лучше использовать статические переменные. Ключевое слово '''static''' обеспечивает защиту от перекрытия имен. Static может использоваться в 5 контекстах:<br />
<br />
'''1. Статические глобальные переменные'''<br />
<source lang="cpp"><br />
// 1.cpp<br />
static int i = 0;<br />
</source><br />
Такое объявление переменной делает ее глобальной в пределах одного cpp файла, в данном случае - 1.cpp.<br />
Если объявить статическую переменную i в заголовочном файле, то в каждом файле, в который будет подключен этот header, будет по одной собственной i.<br />
<br />
''Замечание: типы линковки.''<br />
<br />
Линковка бывает:<br />
* external - функции и переменные между модулями;<br />
* internal - внутри одного модуля. Пример использования - счетчик открытых файлов.<br />
<br />
'''2. Статические функции'''<br />
<br />
Внутренняя линковка (internal). <br />
<br />
Можно создавать разные функции с одинаковыми сигнатурами. Так как они определяются во время вызова, то могут и встроиться :).<br />
<br />
Пример: можно в каждом cpp файле создать свою функцию static void test(). Напомню, что ключевое слово static защищает от перекрытия имен.<br />
<br />
'''3. Статические локальные переменные'''<br />
<br />
Рассмотрим следующую функцию:<br />
<source lang="cpp"><br />
void print (double x) {<br />
static int i = 0;<br />
std::cout << (++i) << x << std::endl;<br />
}<br />
</source><br />
Переменная i хранится не хранится на стеке. По сути, она является глобальной переменной, но ее областью видимости является только функция print.<br />
<br />
Статические локальные переменные уничтожаются при выходе из main().<br />
<br />
Если сделать функцию print статической и вставить в несколько cpp файлов, то у каждого print будет свой счетчик i и своя реализация. А если сделать ее inline, то 1 общая реализация.<br />
<br />
Рассмотрим еще один пример:<br />
<source lang="cpp"><br />
1. void print (char const * fn, double x) {<br />
2. static int i = 0;<br />
3. static ofstream file(fn) = q(); // q() - некоторая функция<br />
4. file << (++i) << x << endl;<br />
5. }<br />
</source><br />
* Если бы переменная ofstream file не была статической, то при каждом входе в print файл открывался бы заново.<br />
* Т.к. file - статическая, то при каждом входе в print, кроме первого раза, строка 3 игнорируется: как инициализация переменной file, так и =q(). <br />
<br />
Применение: храниение локальных данных функций.<br />
<source lang="cpp"><br />
char * g() {<br />
static char m[100];<br />
return m; // имеет смысл, т.к. m static => хранится не на стеке<br />
}<br />
</source><br />
<br />
Статические переменные так же можно возвращать по ссылке:<br />
<source lang="cpp"><br />
string & g() {<br />
static string s;<br />
return s;<br />
}<br />
</source><br />
<br />
''Недостаток использования статических локальных переменных:''<br />
* невозможно проследить, кто и когда их изменяет. В многопоточных приложениях от них вообще стоит отказаться :)<br />
<br />
Тем не менее, это эффективнее, чем выделение динамической памяти.<br />
<br />
'''4. Статические члены данных класса '''<br />
Вышесказанное относилось как к С++, так и к С. Этот и следующий параграфы, очевидно, относятся только к С++.<br />
<br />
Рассмотрим пример:<br />
<source lang="cpp"><br />
class Array {<br />
private:<br />
static int count_; // объявление статического члена данных класса. Он не хранится в объекте класса.<br />
static string name_; // Статические члены данных класса подобны глобальным переменным внутри класса. <br />
};<br />
</source><br />
В данном примере статические члены данных объявлены private, поэтому изменять их можно только из внутренних методов класса или "друзьями" (friend).<br />
Для того, чтобы проинициализировать статические члены данных, их нужно определить в каком-нибудь срр-файле, чтобы выделилась память:<br />
<source lang="cpp"><br />
Array::count_ = 0;<br />
string Array::name_("Array");<br />
</source><br />
<br />
Определить статическое поле внутри класса можно тогда и только тогда, когда оно целочисленное и константное (т.к. в момент компиляции работа только с целочисленными типами):<br />
<source lang="cpp"><br />
static int const dimension = 10;<br />
</source><br />
<br />
''Примеры использования:''<br />
* подсчет количества экземпляров класса;<br />
* хранение информации, общей для всех экземпляров класса;<br />
* хранение списка объектов класса.<br />
<br />
<br />
'''5. Статические методы класса'''<br />
<br />
Не зависят от объектов класса. Рассмотрим пример:<br />
<source lang="cpp"><br />
class Array {<br />
private:<br />
static string name_;<br />
public:<br />
static string getName() { // rem. getName() - inline, т.к. определена внутри класса <br />
return name_;<br />
}<br />
};<br />
<br />
int main() {<br />
Array a;<br />
a.getName(); // cинтаксически возможно, но логически неправильно<br />
<br />
Array::getName(); // правильно<br />
}<br />
</source><br />
<br />
Метод getName() не имеет доступа к членам класса, но если передать в нее ссылку на объект класса, то из getName() можно будет изменять private поля.<br />
<br />
Невозможно объявить статический метод класса константным, так как const запрещает изменять поля объекта, а в static методы this не передается:<br />
<source lang="cpp"><br />
static void f() const; // ошибка!<br />
</source><br />
<br />
'''template и static'''<br />
<br />
* Поведение статических локальных переменных в шаблонах функций: для каждого инстанса функции будет своя статическая локальная переменная.<br />
* Static в шаблонах классов:<br />
<source lang="cpp"><br />
template <class T> <br />
class Array {};<br />
</source><br />
Для каждого инстанса класса будут свои статические поля и методы. <br />
<br />
Но как определить снаружи статическую переменную шаблонного класса?<br />
<br />
1 вариант:<br />
<source lang="cpp"><br />
// array.h<br />
template <class T><br />
class Array <br />
{<br />
static double q;<br />
public:<br />
Array();<br />
static double getQ() { <br />
return q;<br />
}<br />
};<br />
<br />
template <class T><br />
double Array<T>::q = 1.5;<br />
<br />
// main.cpp<br />
#include <iostream><br />
#include "array.h"<br />
<br />
int main()<br />
{<br />
std::cout << Array<int>::getQ() << std::endl;<br />
std::cout << Array<float>::getQ() << std::endl;<br />
return 0;<br />
}<br />
<br />
//output: 1.5, 1.5<br />
</source><br />
<br />
2 вариант:<br />
<source lang="cpp"><br />
// array.h<br />
template <class T><br />
class Array <br />
{<br />
static double q;<br />
public:<br />
Array();<br />
static double getQ() { <br />
return q;<br />
}<br />
};<br />
<br />
//array.cpp<br />
#include "array.h"<br />
<br />
template <><br />
double Array<int>::q = 1.5;<br />
template <><br />
double Array<float>::q = 2.6;<br />
<br />
// main.cpp<br />
#include <iostream><br />
#include "array.h"<br />
<br />
int main()<br />
{<br />
std::cout << Array<int>::getQ() << std::endl;<br />
std::cout << Array<float>::getQ() << std::endl;<br />
return 0;<br />
}<br />
<br />
// output: 1.5, 2.6<br />
</source><br />
<br />
Rem. Вообще, шаблоны не очень дружат со static параметром шаблона: не может быть указателя на статическую функцию.<br />
<br />
==Синглтон==</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%9D%D0%B0%D0%BF%D0%BE%D0%BC%D0%B8%D0%BD%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%BE_inline_%D0%B8_static._%D0%A1%D0%B8%D0%BD%D0%B3%D0%BB%D1%82%D0%BE%D0%BD.&diff=199Напоминание про inline и static. Синглтон.2011-05-02T08:19:31Z<p>Katepol: /* Inline */</p>
<hr />
<div>==Inline==<br />
Рассмотрим некоторую inline функцию:<br />
<source lang="cpp"><br />
inline void f() {}<br />
</source><br />
'''Где ее разместить: в cpp или в header'e?'''<br />
<br />
1) При размещении любой функции в заголовочном файле, если данный header включен в несколько файлов вашего проекта, проект упадет при линковке, если ваша функция не inline.<br />
<br />
2) Если вы создаете inline функцию, то ее нужно размещать в header'e, так как<br />
* определение функции должно быть видно из того места в коде, где она используется;<br />
* если разделить определение и тело inline функции, то ее можно будет использовать только в том cpp файле, в котором находится ее тело.<br />
<br />
Если определить метод внутри класса, то он автоматически становится inline:<br />
<source lang="cpp"><br />
class T {<br />
int size_;<br />
public:<br />
size_t getSize() const { // inline!<br />
return size_;<br />
}<br />
};<br />
</source> <br />
<br />
Шаблонные функции - тоже inline, по очевидной причине: шаблонная функция должна быть определена к моменту вызова (при инстанциировании).<br />
<source lang="cpp"><br />
template <typename T><br />
void swap (T & a, T & b) {<br />
...<br />
}<br />
</source><br />
<br />
==Глобальные переменные==<br />
Что мы о них знаем? Что их не нужно использовать :), так как невозможно спрогнозировать, что лежит в этой переменной.<br />
Если у нас все же есть глобальная переменная и она определена в нескольких cpp файлах, то наша программа упадет при линковке. Избежать этого позволяет ключевое слово '''extern''':<br />
<source lang="cpp"><br />
// 1.cpp<br />
int i = 0;<br />
<br />
// 2.cpp<br />
extern int i; // extern указывает на то, что i определена где-то снаружи<br />
</source><br />
<br />
На самом деле, перед любым объявлением функции автоматически ставится extern (можно явно писать, ошибки не будет).<br />
<br />
==Статические переменные==<br />
Если уж очень нужны глобальные переменные, лучше использовать статические переменные. Ключевое слово '''static''' обеспечивает защиту от перекрытия имен. Static может использоваться в 5 контекстах:<br />
'''1. Статические глобальные переменные'''<br />
<source lang="cpp"><br />
// 1.cpp<br />
static int i = 0;<br />
</source><br />
Такое объявление переменной делает ее глобальной в пределах одного cpp файла, в данном случае - 1.cpp.<br />
Если объявить статическую переменную i в заголовочном файле, то в каждом файле, в который будет подключен этот header, будет по одной собственной i.<br />
<br />
''Замечание: типы линковки.''<br />
Линковка бывает:<br />
* external - функции и переменные между модулями;<br />
* internal - внутри одного модуля. Пример использования - счетчик открытых файлов.<br />
<br />
'''2. Статические функции'''<br />
Внутренняя линковка (internal). <br />
Можно создавать разные функции с одинаковыми сигнатурами. Так как они определяются во время вызова, то могут и встроиться :).<br />
Пример: можно в каждом cpp файле создать свою функцию static void test(). Напомню, что ключевое слово static защищает от перекрытия имен.<br />
<br />
'''3. Статические локальные переменные'''<br />
Рассмотрим следующую функцию:<br />
<source lang="cpp"><br />
void print (double x) {<br />
static int i = 0;<br />
std::cout << (++i) << x << std::endl;<br />
}<br />
</source><br />
Переменная i хранится не хранится на стеке (А ГДЕ?). По сути, она является глобальной переменной, но ее областью видимости является только функция print.<br />
<br />
Если сделать функцию print статической и вставить в несколько cpp файлов, то у каждого print будет свой счетчик i и своя реализация. А если сделать ее inline, то 1 общая реализация.<br />
<br />
Рассмотрим еще один пример:<br />
<source lang="cpp"><br />
void print (char const * fn, double x) {<br />
static int i = 0;<br />
static ofstream file(fn) = q(); // q() - некоторая функция<br />
file << (++i) << x << endl;<br />
}<br />
* Если бы переменная ofstream file не была статической, то при каждом входе в print файл открывался бы заново.<br />
* Т.к. file - статическая, то при каждом входе в print <br />
</source><br />
<br />
'''4. Статические члены класса'''<br />
'''5. Статические методы класса'''<br />
<br />
==Синглтон==</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%9D%D0%B0%D0%BF%D0%BE%D0%BC%D0%B8%D0%BD%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%BE_inline_%D0%B8_static._%D0%A1%D0%B8%D0%BD%D0%B3%D0%BB%D1%82%D0%BE%D0%BD.&diff=198Напоминание про inline и static. Синглтон.2011-04-23T10:00:09Z<p>Katepol: /* Статические переменные */</p>
<hr />
<div>==Inline==<br />
Рассмотрим некоторую inline функцию:<br />
<source lang="cpp"><br />
inline void f() {}<br />
</source><br />
'''Где ее разместить: в cpp или в header'e?'''<br />
<br />
1) При размещении любой функции в заголовочном файле, если данный header включен в несколько файлов вашего проекта, проект упадет при линковке, если ваша функция не inline.<br />
<br />
2) Ключевое слово inline обязывает программиста размещать такую функцию в header'e, так как<br />
* определение функции должно быть видно из того места в коде, где она используется;<br />
* если разделить определение и тело inline функции, то ее можно будет использовать только в том cpp файле, в котором находится ее тело.<br />
<br />
Если определить метод внутри класса, то он автоматически становится inline:<br />
<source lang="cpp"><br />
class T {<br />
int size_;<br />
public:<br />
size_t getSize() const { // inline!<br />
return size_;<br />
}<br />
};<br />
</source> <br />
<br />
Шаблонные функции - тоже inline, по очевидной причине: шаблонная функция должна быть определена к моменту вызова (при инстанциировании).<br />
<source lang="cpp"><br />
template <typename T><br />
void swap (T & a, T & b) {<br />
...<br />
}<br />
</source><br />
<br />
==Глобальные переменные==<br />
Что мы о них знаем? Что их не нужно использовать :), так как невозможно спрогнозировать, что лежит в этой переменной.<br />
Если у нас все же есть глобальная переменная и она определена в нескольких cpp файлах, то наша программа упадет при линковке. Избежать этого позволяет ключевое слово '''extern''':<br />
<source lang="cpp"><br />
// 1.cpp<br />
int i = 0;<br />
<br />
// 2.cpp<br />
extern int i; // extern указывает на то, что i определена где-то снаружи<br />
</source><br />
<br />
На самом деле, перед любым объявлением функции автоматически ставится extern (можно явно писать, ошибки не будет).<br />
<br />
==Статические переменные==<br />
Если уж очень нужны глобальные переменные, лучше использовать статические переменные. Ключевое слово '''static''' обеспечивает защиту от перекрытия имен. Static может использоваться в 5 контекстах:<br />
'''1. Статические глобальные переменные'''<br />
<source lang="cpp"><br />
// 1.cpp<br />
static int i = 0;<br />
</source><br />
Такое объявление переменной делает ее глобальной в пределах одного cpp файла, в данном случае - 1.cpp.<br />
Если объявить статическую переменную i в заголовочном файле, то в каждом файле, в который будет подключен этот header, будет по одной собственной i.<br />
<br />
''Замечание: типы линковки.''<br />
Линковка бывает:<br />
* external - функции и переменные между модулями;<br />
* internal - внутри одного модуля. Пример использования - счетчик открытых файлов.<br />
<br />
'''2. Статические функции'''<br />
Внутренняя линковка (internal). <br />
Можно создавать разные функции с одинаковыми сигнатурами. Так как они определяются во время вызова, то могут и встроиться :).<br />
Пример: можно в каждом cpp файле создать свою функцию static void test(). Напомню, что ключевое слово static защищает от перекрытия имен.<br />
<br />
'''3. Статические локальные переменные'''<br />
Рассмотрим следующую функцию:<br />
<source lang="cpp"><br />
void print (double x) {<br />
static int i = 0;<br />
std::cout << (++i) << x << std::endl;<br />
}<br />
</source><br />
Переменная i хранится не хранится на стеке (А ГДЕ?). По сути, она является глобальной переменной, но ее областью видимости является только функция print.<br />
<br />
Если сделать функцию print статической и вставить в несколько cpp файлов, то у каждого print будет свой счетчик i и своя реализация. А если сделать ее inline, то 1 общая реализация.<br />
<br />
Рассмотрим еще один пример:<br />
<source lang="cpp"><br />
void print (char const * fn, double x) {<br />
static int i = 0;<br />
static ofstream file(fn) = q(); // q() - некоторая функция<br />
file << (++i) << x << endl;<br />
}<br />
* Если бы переменная ofstream file не была статической, то при каждом входе в print файл открывался бы заново.<br />
* Т.к. file - статическая, то при каждом входе в print <br />
</source><br />
<br />
'''4. Статические члены класса'''<br />
'''5. Статические методы класса'''<br />
<br />
==Синглтон==</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%9D%D0%B0%D0%BF%D0%BE%D0%BC%D0%B8%D0%BD%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%BE_inline_%D0%B8_static._%D0%A1%D0%B8%D0%BD%D0%B3%D0%BB%D1%82%D0%BE%D0%BD.&diff=196Напоминание про inline и static. Синглтон.2011-04-23T09:35:30Z<p>Katepol: /* Inline */</p>
<hr />
<div>==Inline==<br />
Рассмотрим некоторую inline функцию:<br />
<source lang="cpp"><br />
inline void f() {}<br />
</source><br />
'''Где ее разместить: в cpp или в header'e?'''<br />
<br />
1) При размещении любой функции в заголовочном файле, если данный header включен в несколько файлов вашего проекта, проект упадет при линковке, если ваша функция не inline.<br />
<br />
2) Ключевое слово inline обязывает программиста размещать такую функцию в header'e, так как<br />
* определение функции должно быть видно из того места в коде, где она используется;<br />
* если разделить определение и тело inline функции, то ее можно будет использовать только в том cpp файле, в котором находится ее тело.<br />
<br />
Если определить метод внутри класса, то он автоматически становится inline:<br />
<source lang="cpp"><br />
class T {<br />
int size_;<br />
public:<br />
size_t getSize() const { // inline!<br />
return size_;<br />
}<br />
};<br />
</source> <br />
<br />
Шаблонные функции - тоже inline, по очевидной причине: шаблонная функция должна быть определена к моменту вызова (при инстанциировании).<br />
<source lang="cpp"><br />
template <typename T><br />
void swap (T & a, T & b) {<br />
...<br />
}<br />
</source><br />
<br />
==Глобальные переменные==<br />
Что мы о них знаем? Что их не нужно использовать :), так как невозможно спрогнозировать, что лежит в этой переменной.<br />
Если у нас все же есть глобальная переменная и она определена в нескольких cpp файлах, то наша программа упадет при линковке. Избежать этого позволяет ключевое слово '''extern''':<br />
<source lang="cpp"><br />
// 1.cpp<br />
int i = 0;<br />
<br />
// 2.cpp<br />
extern int i; // extern указывает на то, что i определена где-то снаружи<br />
</source><br />
<br />
На самом деле, перед любым объявлением функции автоматически ставится extern (можно явно писать, ошибки не будет).<br />
<br />
==Статические переменные==<br />
Если уж очень нужны глобальные переменные, лучше использовать статические переменные. Ключевое слово '''static''' обеспечивает защиту от перекрытия имен. Static может использоваться в 5 контекстах:<br />
===1. Статические глобальные переменные===<br />
===2. Статические функции===<br />
===3. Статические локальные переменные===<br />
===4. Статические члены класса===<br />
===5. Статические методы класса===<br />
<br />
==Синглтон==</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%9D%D0%B0%D0%BF%D0%BE%D0%BC%D0%B8%D0%BD%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%BE_inline_%D0%B8_static._%D0%A1%D0%B8%D0%BD%D0%B3%D0%BB%D1%82%D0%BE%D0%BD.&diff=195Напоминание про inline и static. Синглтон.2011-04-23T09:34:59Z<p>Katepol: /* Inline */</p>
<hr />
<div>==Inline==<br />
Рассмотрим некоторую inline функцию:<br />
<source lang="cpp"><br />
inline void f() {}<br />
</source><br />
'''Где ее разместить: в cpp или в header'e?'''<br />
1) При размещении любой функции в заголовочном файле, если данный header включен в несколько файлов вашего проекта, проект упадет при линковке, если ваша функция не inline.<br />
2) Ключевое слово inline обязывает программиста размещать такую функцию в header'e, так как<br />
* определение функции должно быть видно из того места в коде, где она используется;<br />
* если разделить определение и тело inline функции, то ее можно будет использовать только в том cpp файле, в котором находится ее тело.<br />
<br />
Если определить метод внутри класса, то он автоматически становится inline:<br />
<source lang="cpp"><br />
class T {<br />
int size_;<br />
public:<br />
size_t getSize() const { // inline!<br />
return size_;<br />
}<br />
};<br />
</source> <br />
<br />
Шаблонные функции - тоже inline, по очевидной причине: шаблонная функция должна быть определена к моменту вызова (при инстанциировании).<br />
<source lang="cpp"><br />
template <typename T><br />
void swap (T & a, T & b) {<br />
...<br />
}<br />
</source><br />
<br />
==Глобальные переменные==<br />
Что мы о них знаем? Что их не нужно использовать :), так как невозможно спрогнозировать, что лежит в этой переменной.<br />
Если у нас все же есть глобальная переменная и она определена в нескольких cpp файлах, то наша программа упадет при линковке. Избежать этого позволяет ключевое слово '''extern''':<br />
<source lang="cpp"><br />
// 1.cpp<br />
int i = 0;<br />
<br />
// 2.cpp<br />
extern int i; // extern указывает на то, что i определена где-то снаружи<br />
</source><br />
<br />
На самом деле, перед любым объявлением функции автоматически ставится extern (можно явно писать, ошибки не будет).<br />
<br />
==Статические переменные==<br />
Если уж очень нужны глобальные переменные, лучше использовать статические переменные. Ключевое слово '''static''' обеспечивает защиту от перекрытия имен. Static может использоваться в 5 контекстах:<br />
===1. Статические глобальные переменные===<br />
===2. Статические функции===<br />
===3. Статические локальные переменные===<br />
===4. Статические члены класса===<br />
===5. Статические методы класса===<br />
<br />
==Синглтон==</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%9A%D0%BE%D0%BD%D1%81%D0%BF%D0%B5%D0%BA%D1%82%D1%8B_%D0%A1%2B%2B&diff=194Конспекты С++2011-04-23T09:28:08Z<p>Katepol: </p>
<hr />
<div>Конспекты по C++<br />
1 семестр (осень-зима 2010)<br />
* [[ Как происходит компиляция|Как происходит компиляция. Алексей Давыдов. 08.09.2010]]<br />
* [[ Указатели и ссылки|Указатели и ссылки. Екатерина Полищук. 10.09.2010]]<br />
* [[ Динамическое распределение памяти|Динамическое распределение памяти. Алексей Гуревич. 17.09.2010]]<br />
* [[ Перегрузка операторов|Перегрузка операторов. Мария Фомкина. 12.11.2010]]<br />
<br />
2 семестр (зима-весна 2011)<br />
* [[ Напоминание про inline и static. Синглтон.|Напоминание про inline и static. Синглтон. Екатерина Полищук. 11.02.2011]]<br />
* [[ STL. Последовательные контейнеры|STL. Последовательные контейнеры. Мария Фомкина. 18.02.2011]]</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%9D%D0%B0%D0%BF%D0%BE%D0%BC%D0%B8%D0%BD%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%BE_inline_%D0%B8_static._%D0%A1%D0%B8%D0%BD%D0%B3%D0%BB%D1%82%D0%BE%D0%BD.&diff=192Напоминание про inline и static. Синглтон.2011-04-23T09:26:17Z<p>Katepol: переименовал «Напоминание про inline и static» в «Напоминание про inline и static. Синглтон.»</p>
<hr />
<div>==Inline==<br />
Рассмотрим некоторую inline функцию:<br />
<source lang="cpp"><br />
inline void f() {}<br />
</source><br />
'''Где ее разместить: в cpp или в header'e?'''<br />
1) При размещении любой функции в заголовочном файле, если данный header включен в несколько файлов вашего проекта, проект упадет при линковке, если ваша функция не inline.<br />
2) Ключевое слово inline обязывает программиста размещать такую функцию в header'e, так как<br />
* определение функции должно быть видно из того места в коде, где она используется;<br />
* если разделить определение и тело inline функции, то ее можно будет использовать только в том cpp файле, в котором находится ее тело.<br />
<br />
Если определить метод внутри класса, то он автоматически становится inline:<br />
<source lang="cpp"><br />
class T {<br />
int size_;<br />
public:<br />
size_t getSize() const { // inline!<br />
return size_;<br />
}<br />
};<br />
</source> <br />
<br />
Шаблонные функции - тоже inline, по очевидной причине: шаблонная функция должна быть определена к моменту вызова (при инстанциировании).<br />
<source lang="cpp"><br />
template <typename T><br />
void swap (T & a, T & b) {<br />
...<br />
}<br />
</source> <br />
<br />
==Глобальные переменные==<br />
Что мы о них знаем? Что их не нужно использовать :), так как невозможно спрогнозировать, что лежит в этой переменной.<br />
Если у нас все же есть глобальная переменная и она определена в нескольких cpp файлах, то наша программа упадет при линковке. Избежать этого позволяет ключевое слово '''extern''':<br />
<source lang="cpp"><br />
// 1.cpp<br />
int i = 0;<br />
<br />
// 2.cpp<br />
extern int i; // extern указывает на то, что i определена где-то снаружи<br />
</source><br />
<br />
На самом деле, перед любым объявлением функции автоматически ставится extern (можно явно писать, ошибки не будет).<br />
<br />
==Статические переменные==<br />
Если уж очень нужны глобальные переменные, лучше использовать статические переменные. Ключевое слово '''static''' обеспечивает защиту от перекрытия имен. Static может использоваться в 5 контекстах:<br />
===1. Статические глобальные переменные===<br />
===2. Статические функции===<br />
===3. Статические локальные переменные===<br />
===4. Статические члены класса===<br />
===5. Статические методы класса===<br />
<br />
==Синглтон==</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%9D%D0%B0%D0%BF%D0%BE%D0%BC%D0%B8%D0%BD%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%BE_inline_%D0%B8_static&diff=193Напоминание про inline и static2011-04-23T09:26:17Z<p>Katepol: переименовал «Напоминание про inline и static» в «Напоминание про inline и static. Синглтон.»</p>
<hr />
<div>#перенаправление [[Напоминание про inline и static. Синглтон.]]</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%9D%D0%B0%D0%BF%D0%BE%D0%BC%D0%B8%D0%BD%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%BE_inline_%D0%B8_static._%D0%A1%D0%B8%D0%BD%D0%B3%D0%BB%D1%82%D0%BE%D0%BD.&diff=191Напоминание про inline и static. Синглтон.2011-04-23T09:25:30Z<p>Katepol: Новая страница: «==Inline== Рассмотрим некоторую inline функцию: <source lang="cpp"> inline void f() {} </source> '''Где ее разместить: в cp…»</p>
<hr />
<div>==Inline==<br />
Рассмотрим некоторую inline функцию:<br />
<source lang="cpp"><br />
inline void f() {}<br />
</source><br />
'''Где ее разместить: в cpp или в header'e?'''<br />
1) При размещении любой функции в заголовочном файле, если данный header включен в несколько файлов вашего проекта, проект упадет при линковке, если ваша функция не inline.<br />
2) Ключевое слово inline обязывает программиста размещать такую функцию в header'e, так как<br />
* определение функции должно быть видно из того места в коде, где она используется;<br />
* если разделить определение и тело inline функции, то ее можно будет использовать только в том cpp файле, в котором находится ее тело.<br />
<br />
Если определить метод внутри класса, то он автоматически становится inline:<br />
<source lang="cpp"><br />
class T {<br />
int size_;<br />
public:<br />
size_t getSize() const { // inline!<br />
return size_;<br />
}<br />
};<br />
</source> <br />
<br />
Шаблонные функции - тоже inline, по очевидной причине: шаблонная функция должна быть определена к моменту вызова (при инстанциировании).<br />
<source lang="cpp"><br />
template <typename T><br />
void swap (T & a, T & b) {<br />
...<br />
}<br />
</source> <br />
<br />
==Глобальные переменные==<br />
Что мы о них знаем? Что их не нужно использовать :), так как невозможно спрогнозировать, что лежит в этой переменной.<br />
Если у нас все же есть глобальная переменная и она определена в нескольких cpp файлах, то наша программа упадет при линковке. Избежать этого позволяет ключевое слово '''extern''':<br />
<source lang="cpp"><br />
// 1.cpp<br />
int i = 0;<br />
<br />
// 2.cpp<br />
extern int i; // extern указывает на то, что i определена где-то снаружи<br />
</source><br />
<br />
На самом деле, перед любым объявлением функции автоматически ставится extern (можно явно писать, ошибки не будет).<br />
<br />
==Статические переменные==<br />
Если уж очень нужны глобальные переменные, лучше использовать статические переменные. Ключевое слово '''static''' обеспечивает защиту от перекрытия имен. Static может использоваться в 5 контекстах:<br />
===1. Статические глобальные переменные===<br />
===2. Статические функции===<br />
===3. Статические локальные переменные===<br />
===4. Статические члены класса===<br />
===5. Статические методы класса===<br />
<br />
==Синглтон==</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%9A%D0%BE%D0%BD%D1%81%D0%BF%D0%B5%D0%BA%D1%82%D1%8B_%D0%A1%2B%2B&diff=190Конспекты С++2011-04-23T08:56:43Z<p>Katepol: </p>
<hr />
<div>Конспекты по C++<br />
1 семестр (осень-зима 2010)<br />
* [[ Как происходит компиляция|Как происходит компиляция. Алексей Давыдов. 08.09.2010]]<br />
* [[ Указатели и ссылки|Указатели и ссылки. Екатерина Полищук. 10.09.2010]]<br />
* [[ Динамическое распределение памяти|Динамическое распределение памяти. Алексей Гуревич. 17.09.2010]]<br />
* [[ Перегрузка операторов|Перегрузка операторов. Мария Фомкина. 12.11.2010]]<br />
<br />
2 семестр (зима-весна 2011)<br />
* [[ Напоминание про inline и static|Напоминание про inline и static. Екатерина Полищук. 11.02.2011]]<br />
* [[ STL. Последовательные контейнеры|STL. Последовательные контейнеры. Мария Фомкина. 18.02.2011]]</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%9A%D0%BE%D0%BD%D1%81%D0%BF%D0%B5%D0%BA%D1%82%D1%8B_%D0%A1%2B%2B&diff=189Конспекты С++2011-04-23T08:56:21Z<p>Katepol: </p>
<hr />
<div>Конспекты по C++<br />
1 семестр (осень-зима 2010)<br />
* [[ Как происходит компиляция|Как происходит компиляция. Алексей Давыдов. 08.09.2010]]<br />
* [[ Указатели и ссылки|Указатели и ссылки. Екатерина Полищук. 10.09.2010]]<br />
* [[ Динамическое распределение памяти|Динамическое распределение памяти. Алексей Гуревич. 17.09.2010]]<br />
* [[ Перегрузка операторов|Перегрузка операторов. Мария Фомкина. 12.11.2010]]<br />
<br />
2 семестр (зима-весна 2011)<br />
* [[ Напоминание про inline и static|Напоминание про inline и static. Екатерина Полищук. 11.02.2010]]<br />
* [[ STL. Последовательные контейнеры|STL. Последовательные контейнеры. Мария Фомкина. 18.02.2011]]</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%A3%D0%BA%D0%B0%D0%B7%D0%B0%D1%82%D0%B5%D0%BB%D0%B8_%D0%B8_%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B8&diff=164Указатели и ссылки2011-03-30T08:00:49Z<p>Katepol: /* Указатели на указатель */</p>
<hr />
<div>==Указатели==<br />
Указатель - это переменная, содержащая адрес другой переменной. Указатели очень широко используются в языке С++. <br />
Это происходит отчасти потому, что иногда они дают единственную возможность выразить нужное действие, а отчасти потому, <br />
что они обычно ведут к более компактным и эффективным программам, чем те, которые могут быть написаны другими способами. <br />
Так как указатель содержит адрес объекта, это дает возможность "косвенного"<br />
доступа к этому объекту через указатель.<br />
<br />
Пример создания указателя на int и на double:<br />
<source lang="cpp"><br />
int a=5;<br />
int *pa = &amp;a;<br />
double d = 1.5;<br />
double *pd = &amp;d;<br />
<br />
pa = pd //нельзя! т.к. указатели на данные разного типа<br />
<br />
pa = (int*)pd; //компилируется<br />
</source><br />
<br />
Последняя операция лишена смысла, т.к. элемент типа double занимает 8 байт, а элемент типа int - 4 байта (в х32). <br />
Поэтому указатель pa будет указывать на первые 4 байта данных, расположенных по<br />
адресу, хранящемуся в pd.<br />
<br />
Рассмотрим пример функции, которая должна менять местами два значения:<br />
<source lang="cpp"><br />
void swap (int a, int b)<br />
{<br />
int t = a;<br />
a = b;<br />
b = t;<br />
}<br />
</source><br />
Вызов swap:<br />
<source lang="cpp"><br />
int k=10, m=20;<br />
swap (k, m);<br />
<br />
</source><br />
Несмотря на то, что все написано правильно, после возврата из функции swap значения k и m не изменились. Это обусловлено <br />
тем, что при передаче в функцию происходит копирование параметров. Таким образом, изменились скопированные значения, <br />
а исходные остались прежними. Чтобы иметь возможность менять параметры их следует передавать по указателю:<br />
<source lang="cpp"><br />
void swap (int *a, int *b)<br />
{<br />
int t = *a;<br />
*a = *b;<br />
*b = *t;<br />
}<br />
</source><br />
Вызов swap:<br />
<source lang="cpp"><br />
int k=10, m=20;<br />
swap (&amp;k, &amp;m);<br />
</source><br />
Теперь значения k и m изменились, так как при передаче в функцию произошло копирование адресов переменных, а адреса мы менять не хотели.<br />
<br />
==Встроенные массивы==<br />
'''Опр.''' Массив - это '''непрерывная''' область памяти, в которой<br />
расположены '''однотипные''' элементы.<br />
<br />
<source lang="cpp"><br />
int a[5] = {1, 2, 3}; //в памяти лежат 1,2,3,0,0<br />
</source><br />
_ _ _ ___________________ _ _<br />
_ _ _ |_1_|_2_|_3_|_0_|_0_|_ _<br />
<br />
''Связь массивов и указателей:'' имя встроенного массива преобразуется в<br />
указатель (на первый элемент массива):<br />
<source lang="cpp"><br />
int *p = 0; //"нулевой" указатель, nil. Означает, что он не указывает ни на какую ячейку памяти.<br />
p = a; // &amp;a[0]<br />
a = p; // обратное (р = а) неверно<br />
</source><br />
<br />
Передача массива в функцию в качестве параметра:<br />
<source lang="cpp"><br />
int max_element (int m[10]) {}<br />
</source><br />
<br />
''Массив передается по ссылке (не копируется).''<br />
Вызов: max_element(a);<br />
Функция max_element будет работать только с массивами из 10 элементов (с другими<br />
- не скомпилируется). Правильнее делать так:<br />
<source lang="cpp"><br />
int max_element (int *m, int size) <br />
{<br />
int max = *m; <br />
for (int i=1; i != size; ++i)<br />
if (m[i] >= max)<br />
max = m[i];<br />
return max;<br />
}<br />
<br />
</source><br />
Вызов: max_element(a, 5); <br />
<br />
Проблемы такой реализации:<br />
* функция не работает с массивами нулевой длины;<br />
* не отследить случаи выхода за границы массива.<br />
<br />
===Арифметика указателей===<br />
Пусть q, p - указатели, а i - число. Возможные операции:<br />
* p+i, p-i сдвиг по массиву на i элементов вправо/влево<br />
* p[i] &lt;=&gt; *(p+i)<br />
* q-p количество элементов массива между p и q. Разность указателей имеет тип size_t.<br />
<br />
Рассмотрим две реализации функции подсчета длины символов в строке:<br />
<source lang="cpp"><br />
int strlen1 (char *s)<br />
{<br />
int len=0;<br />
while (s[len]!=0)<br />
++len;<br />
return len;<br />
}<br />
<br />
int strlen2 (char *s)<br />
{<br />
char *p = s;<br />
while (*p!=0)<br />
++p;<br />
return p-s;<br />
}<br />
</source><br />
<br />
Первая реализация более трудоемка, так как s[len] &lt;=&gt; *(s+len) то есть смещению по массиву и разименованию (2 операции), <br />
в то время, как во второй реализации мы работаем с указателями напрямую. Но второй вариант менее читабелен.<br />
Второй способ (работу с указателями напрямую) следует использовать и при<br />
передаче массива в функцию.<br />
<br />
Рекомендуется следующая сигнатура:<br />
<source lang="cpp"><br />
int foo (int *first, int *last);<br />
</source><br />
Где first является указателем на первый элемент массивва (a[0]), а last указателем на область памяти сразу за массивом ("a[n]"). <br />
Такой выбор указателя last обеспечивает работу с массивами нулевой длины.<br />
Перепишем функцию max_element:<br />
<source lang="cpp"><br />
int* max_element (int *m, int *last)<br />
{<br />
int *max = m;<br />
for (; m != last; ++m)<br />
if (*m >= *max)<br />
max = m;<br />
return max;<br />
}<br />
</source><br />
Вызов: max_element(a, a+5);<br />
Следует отметить, что теперь функция max_element возвращает не значение<br />
максимального элемента массива, а указатель на него.<br />
<br />
==Указатели на указатель==<br />
Рассмотрим функцию поиска символа в строке, возвращающую позицию искомого элемента:<br />
<source lang="cpp"><br />
int findch (char *s, char p)<br />
{<br />
for (int i = 0; s[i] != 0; ++i)<br />
if (s[i] == p)<br />
return i;<br />
return -1;<br />
}<br />
</source><br />
Вообще данная функция должна информировать о двух вещах: во-первых, найден ли искомый символ, а во-вторых, если да, то его позицию. <br />
Будет правильно возвращать 2 значения соответственно, а не совмещать все в одном. Перепишем функцию:<br />
<source lang="cpp"><br />
bool findch (char *s, char p, int *n=0)<br />
{<br />
for (int i = 0; s[i] != 0; ++i)<br />
if (s[i] == p)<br />
{<br />
*n = i;<br />
return true;<br />
}<br />
return false;<br />
}<br />
</source><br />
Вызов: <br />
<source lang="cpp"><br />
int idx = 0;<br />
if (findch(s, ' ', &amp;idx)) {...}<br />
</source><br />
<br />
Чтобы возвращать не индекс элемента, а его позицию в массиве используют<br />
указатель на указатель:<br />
<source lang="cpp"><br />
bool findch (char *s, char p, char **pos=0)<br />
{<br />
while (*s!=0)<br />
{<br />
if (*s==p)<br />
{<br />
if (pos)<br />
*pos=s;<br />
return true;<br />
}<br />
++s;<br />
}<br />
return false;<br />
} <br />
</source><br />
Вызов:<br />
<source lang="cpp"><br />
char *pos = 0;<br />
if (findch(s, ' ', &amp;pos) {...}<br />
</source><br />
<br />
Работа с указательями напрямую синтаксически неудобна. Для достижения<br />
удобства используют ссылки:<br />
<source lang="cpp"><br />
int a = 5;<br />
int &amp;b = a; //b - ссылка на а<br />
<br />
b = 10; //в а тоже стало 10<br />
</source><br />
Функция swap с использованием ссылок будет выглядеть так:<br />
<source lang="cpp"><br />
void swap (int &amp;a, int &amp;b)<br />
{<br />
int t=b;<br />
b=a;<br />
a=t;<br />
}<br />
</source><br />
Вызов:<br />
<source lang="cpp"><br />
int c = 30;<br />
swap (a, c);<br />
</source><br />
При передаче параметров в функцию по ссылке копирования данных не<br />
происходит.<br />
<br />
===Различия ссылок и указателей===<br />
* Ссылку нельзя не проинициализировать (ссылка не может быть неинициализированной); ссылку нельзя переинициализировать.<br />
* Нельзя получить адрес ссылки или ссылку на ссылку.<br />
* Нельзя создавать массивы ссылок.<br />
<br />
''Замечание:''<br />
* &amp;q взятие адреса переменной q<br />
* *pa разименование<br />
* int &amp;a передача переменной а по ссылке<br />
* int *pa передача переменной по адресу.</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%A3%D0%BA%D0%B0%D0%B7%D0%B0%D1%82%D0%B5%D0%BB%D0%B8_%D0%B8_%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B8&diff=163Указатели и ссылки2011-03-30T07:59:50Z<p>Katepol: /* Встроенные массивы */</p>
<hr />
<div>==Указатели==<br />
Указатель - это переменная, содержащая адрес другой переменной. Указатели очень широко используются в языке С++. <br />
Это происходит отчасти потому, что иногда они дают единственную возможность выразить нужное действие, а отчасти потому, <br />
что они обычно ведут к более компактным и эффективным программам, чем те, которые могут быть написаны другими способами. <br />
Так как указатель содержит адрес объекта, это дает возможность "косвенного"<br />
доступа к этому объекту через указатель.<br />
<br />
Пример создания указателя на int и на double:<br />
<source lang="cpp"><br />
int a=5;<br />
int *pa = &amp;a;<br />
double d = 1.5;<br />
double *pd = &amp;d;<br />
<br />
pa = pd //нельзя! т.к. указатели на данные разного типа<br />
<br />
pa = (int*)pd; //компилируется<br />
</source><br />
<br />
Последняя операция лишена смысла, т.к. элемент типа double занимает 8 байт, а элемент типа int - 4 байта (в х32). <br />
Поэтому указатель pa будет указывать на первые 4 байта данных, расположенных по<br />
адресу, хранящемуся в pd.<br />
<br />
Рассмотрим пример функции, которая должна менять местами два значения:<br />
<source lang="cpp"><br />
void swap (int a, int b)<br />
{<br />
int t = a;<br />
a = b;<br />
b = t;<br />
}<br />
</source><br />
Вызов swap:<br />
<source lang="cpp"><br />
int k=10, m=20;<br />
swap (k, m);<br />
<br />
</source><br />
Несмотря на то, что все написано правильно, после возврата из функции swap значения k и m не изменились. Это обусловлено <br />
тем, что при передаче в функцию происходит копирование параметров. Таким образом, изменились скопированные значения, <br />
а исходные остались прежними. Чтобы иметь возможность менять параметры их следует передавать по указателю:<br />
<source lang="cpp"><br />
void swap (int *a, int *b)<br />
{<br />
int t = *a;<br />
*a = *b;<br />
*b = *t;<br />
}<br />
</source><br />
Вызов swap:<br />
<source lang="cpp"><br />
int k=10, m=20;<br />
swap (&amp;k, &amp;m);<br />
</source><br />
Теперь значения k и m изменились, так как при передаче в функцию произошло копирование адресов переменных, а адреса мы менять не хотели.<br />
<br />
==Встроенные массивы==<br />
'''Опр.''' Массив - это '''непрерывная''' область памяти, в которой<br />
расположены '''однотипные''' элементы.<br />
<br />
<source lang="cpp"><br />
int a[5] = {1, 2, 3}; //в памяти лежат 1,2,3,0,0<br />
</source><br />
_ _ _ ___________________ _ _<br />
_ _ _ |_1_|_2_|_3_|_0_|_0_|_ _<br />
<br />
''Связь массивов и указателей:'' имя встроенного массива преобразуется в<br />
указатель (на первый элемент массива):<br />
<source lang="cpp"><br />
int *p = 0; //"нулевой" указатель, nil. Означает, что он не указывает ни на какую ячейку памяти.<br />
p = a; // &amp;a[0]<br />
a = p; // обратное (р = а) неверно<br />
</source><br />
<br />
Передача массива в функцию в качестве параметра:<br />
<source lang="cpp"><br />
int max_element (int m[10]) {}<br />
</source><br />
<br />
''Массив передается по ссылке (не копируется).''<br />
Вызов: max_element(a);<br />
Функция max_element будет работать только с массивами из 10 элементов (с другими<br />
- не скомпилируется). Правильнее делать так:<br />
<source lang="cpp"><br />
int max_element (int *m, int size) <br />
{<br />
int max = *m; <br />
for (int i=1; i != size; ++i)<br />
if (m[i] >= max)<br />
max = m[i];<br />
return max;<br />
}<br />
<br />
</source><br />
Вызов: max_element(a, 5); <br />
<br />
Проблемы такой реализации:<br />
* функция не работает с массивами нулевой длины;<br />
* не отследить случаи выхода за границы массива.<br />
<br />
===Арифметика указателей===<br />
Пусть q, p - указатели, а i - число. Возможные операции:<br />
* p+i, p-i сдвиг по массиву на i элементов вправо/влево<br />
* p[i] &lt;=&gt; *(p+i)<br />
* q-p количество элементов массива между p и q. Разность указателей имеет тип size_t.<br />
<br />
Рассмотрим две реализации функции подсчета длины символов в строке:<br />
<source lang="cpp"><br />
int strlen1 (char *s)<br />
{<br />
int len=0;<br />
while (s[len]!=0)<br />
++len;<br />
return len;<br />
}<br />
<br />
int strlen2 (char *s)<br />
{<br />
char *p = s;<br />
while (*p!=0)<br />
++p;<br />
return p-s;<br />
}<br />
</source><br />
<br />
Первая реализация более трудоемка, так как s[len] &lt;=&gt; *(s+len) то есть смещению по массиву и разименованию (2 операции), <br />
в то время, как во второй реализации мы работаем с указателями напрямую. Но второй вариант менее читабелен.<br />
Второй способ (работу с указателями напрямую) следует использовать и при<br />
передаче массива в функцию.<br />
<br />
Рекомендуется следующая сигнатура:<br />
<source lang="cpp"><br />
int foo (int *first, int *last);<br />
</source><br />
Где first является указателем на первый элемент массивва (a[0]), а last указателем на область памяти сразу за массивом ("a[n]"). <br />
Такой выбор указателя last обеспечивает работу с массивами нулевой длины.<br />
Перепишем функцию max_element:<br />
<source lang="cpp"><br />
int* max_element (int *m, int *last)<br />
{<br />
int *max = m;<br />
for (; m != last; ++m)<br />
if (*m >= *max)<br />
max = m;<br />
return max;<br />
}<br />
</source><br />
Вызов: max_element(a, a+5);<br />
Следует отметить, что теперь функция max_element возвращает не значение<br />
максимального элемента массива, а указатель на него.<br />
<br />
==Указатели на указатель==<br />
Рассмотрим функцию поиска символа в строке, возвращающую позицию искомого элемента:<br />
<source lang="cpp"><br />
int findch (char *s, char p)<br />
{<br />
for (int i = 0; s[i] != 0; ++i)<br />
if (s[i] == p)<br />
return i;<br />
return -1;<br />
}<br />
</source><br />
Вообще данная функция должна информировать о двух вещах: во-первых, найден ли искомый символ, а во-вторых, если да, то его позицию. <br />
Будет правильно возвращать 2 значения соответственно, а не совмещать все в одном. Перепишем функцию:<br />
<source lang="cpp"><br />
bool findch (char *s, char p, int *n=0)<br />
{<br />
for (int i = 0; s[i] != 0; ++i)<br />
if (s[i] == p)<br />
{<br />
*n = i;<br />
return true;<br />
}<br />
return false;<br />
}<br />
</source><br />
Вызов: <br />
<source lang="cpp"><br />
int idx = 0;<br />
if (findch(s, ' ', &amp;idx)) {...}<br />
</source><br />
<br />
Чтобы возвращать не индекс элемента, а его позицию в массиве используют<br />
указатель на указатель:<br />
<source lang="cpp"><br />
bool findch (char *s, char p, char **pos=0)<br />
{<br />
while (*s!=0)<br />
{<br />
if (*s==p)<br />
{<br />
if (pos)<br />
*pos=s;<br />
return true;<br />
}<br />
++s;<br />
}<br />
return false;<br />
} <br />
</source><br />
Вызов:<br />
<source lang="cpp"><br />
char *pos = 0;<br />
if (findch(s, ' ', &amp;pos) {...}<br />
</source><br />
<br />
Работа с указательями напрямую синтаксически неудобна. Для достижения<br />
удобства используют ссылки:<br />
<source lang="cpp"><br />
int a = 5;<br />
int &amp;b = a; ''//b - ссылка на а''<br />
<br />
b = 10; ''//в а тоже стало 10''<br />
</source><br />
Функция swap с использованием ссылок будет выглядеть так:<br />
<source lang="cpp"><br />
void swap (int &amp;a, int &amp;b)<br />
{<br />
int t=b;<br />
b=a;<br />
a=t;<br />
}<br />
</source><br />
Вызов:<br />
<source lang="cpp"><br />
int c = 30;<br />
swap (a, c);<br />
</source><br />
При передаче параметров в функцию по ссылке копирования данных не<br />
происходит.<br />
<br />
===Различия ссылок и указателей===<br />
* Ссылку нельзя не проинициализировать (ссылка не может быть неинициализированной); ссылку нельзя переинициализировать.<br />
* Нельзя получить адрес ссылки или ссылку на ссылку.<br />
* Нельзя создавать массивы ссылок.<br />
<br />
''Замечание:''<br />
* &amp;q взятие адреса переменной q<br />
* *pa разименование<br />
* int &amp;a передача переменной а по ссылке<br />
* int *pa передача переменной по адресу.</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%A3%D0%BA%D0%B0%D0%B7%D0%B0%D1%82%D0%B5%D0%BB%D0%B8_%D0%B8_%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B8&diff=162Указатели и ссылки2011-03-30T07:58:36Z<p>Katepol: /* Встроенные массивы */</p>
<hr />
<div>==Указатели==<br />
Указатель - это переменная, содержащая адрес другой переменной. Указатели очень широко используются в языке С++. <br />
Это происходит отчасти потому, что иногда они дают единственную возможность выразить нужное действие, а отчасти потому, <br />
что они обычно ведут к более компактным и эффективным программам, чем те, которые могут быть написаны другими способами. <br />
Так как указатель содержит адрес объекта, это дает возможность "косвенного"<br />
доступа к этому объекту через указатель.<br />
<br />
Пример создания указателя на int и на double:<br />
<source lang="cpp"><br />
int a=5;<br />
int *pa = &amp;a;<br />
double d = 1.5;<br />
double *pd = &amp;d;<br />
<br />
pa = pd //нельзя! т.к. указатели на данные разного типа<br />
<br />
pa = (int*)pd; //компилируется<br />
</source><br />
<br />
Последняя операция лишена смысла, т.к. элемент типа double занимает 8 байт, а элемент типа int - 4 байта (в х32). <br />
Поэтому указатель pa будет указывать на первые 4 байта данных, расположенных по<br />
адресу, хранящемуся в pd.<br />
<br />
Рассмотрим пример функции, которая должна менять местами два значения:<br />
<source lang="cpp"><br />
void swap (int a, int b)<br />
{<br />
int t = a;<br />
a = b;<br />
b = t;<br />
}<br />
</source><br />
Вызов swap:<br />
<source lang="cpp"><br />
int k=10, m=20;<br />
swap (k, m);<br />
<br />
</source><br />
Несмотря на то, что все написано правильно, после возврата из функции swap значения k и m не изменились. Это обусловлено <br />
тем, что при передаче в функцию происходит копирование параметров. Таким образом, изменились скопированные значения, <br />
а исходные остались прежними. Чтобы иметь возможность менять параметры их следует передавать по указателю:<br />
<source lang="cpp"><br />
void swap (int *a, int *b)<br />
{<br />
int t = *a;<br />
*a = *b;<br />
*b = *t;<br />
}<br />
</source><br />
Вызов swap:<br />
<source lang="cpp"><br />
int k=10, m=20;<br />
swap (&amp;k, &amp;m);<br />
</source><br />
Теперь значения k и m изменились, так как при передаче в функцию произошло копирование адресов переменных, а адреса мы менять не хотели.<br />
<br />
==Встроенные массивы==<br />
'''Опр.''' Массив - это '''непрерывная''' область памяти, в которой<br />
расположены '''однотипные''' элементы.<br />
<br />
<source lang="cpp"><br />
int a[5] = {1, 2, 3}; //в памяти лежат 1,2,3,0,0<br />
</source><br />
_ _ _ ___________________ _ _<br />
_ _ _ |_1_|_2_|_3_|_0_|_0_|_ _<br />
<br />
''Связь массивов и указателей:'' имя встроенного массива преобразуется в<br />
указатель (на первый элемент массива):<br />
<source lang="cpp"><br />
int *p = 0; //"нулевой" указатель, nil. Означает, что он не указывает ни на какую ячейку памяти.<br />
p = a; // &amp;a[0]<br />
a = p; // обратное (р = а) неверно<br />
</source><br />
<br />
Передача массива в функцию в качестве параметра:<br />
<source lang="cpp"><br />
int max_element (int m[10]) {}<br />
</source><br />
<br />
''Массив передается по ссылке (не копируется).''<br />
Вызов: max_element(a);<br />
Функция max_element будет работать только с массивами из 10 элементов (с другими<br />
- не скомпилируется). Правильнее делать так:<br />
<source lang="cpp"><br />
int max_element (int *m, int size) <br />
{<br />
int max = *m; <br />
for (int i=1; i &amp;lt size; ++i)<br />
if (m[i] &amp;lt max)<br />
max = m[i];<br />
return max;<br />
}<br />
<br />
</source><br />
Вызов: max_element(a, 5); <br />
<br />
Проблемы такой реализации:<br />
* функция не работает с массивами нулевой длины;<br />
* не отследить случаи выхода за границы массива.<br />
<br />
===Арифметика указателей===<br />
Пусть q, p - указатели, а i - число. Возможные операции:<br />
* p+i, p-i сдвиг по массиву на i элементов вправо/влево<br />
* p[i] &lt;=&gt; *(p+i)<br />
* q-p количество элементов массива между p и q. Разность указателей имеет тип size_t.<br />
<br />
Рассмотрим две реализации функции подсчета длины символов в строке:<br />
<source lang="cpp"><br />
int strlen1 (char *s)<br />
{<br />
int len=0;<br />
while (s[len]!=0)<br />
++len;<br />
return len;<br />
}<br />
<br />
int strlen2 (char *s)<br />
{<br />
char *p = s;<br />
while (*p!=0)<br />
++p;<br />
return p-s;<br />
}<br />
</source><br />
<br />
Первая реализация более трудоемка, так как s[len] &lt;=&gt; *(s+len) то есть смещению по массиву и разименованию (2 операции), <br />
в то время, как во второй реализации мы работаем с указателями напрямую. Но второй вариант менее читабелен.<br />
Второй способ (работу с указателями напрямую) следует использовать и при<br />
передаче массива в функцию.<br />
<br />
Рекомендуется следующая сигнатура:<br />
<source lang="cpp"><br />
int foo (int *first, int *last);<br />
</source><br />
Где first является указателем на первый элемент массивва (a[0]), а last указателем на область памяти сразу за массивом ("a[n]"). <br />
Такой выбор указателя last обеспечивает работу с массивами нулевой длины.<br />
Перепишем функцию max_element:<br />
<source lang="cpp"><br />
int* max_element (int *m, int *last)<br />
{<br />
int *max = m;<br />
for (; m != last; ++m)<br />
if (*m >= *max)<br />
max = m;<br />
return max;<br />
}<br />
</source><br />
Вызов: max_element(a, a+5);<br />
Следует отметить, что теперь функция max_element возвращает не значение<br />
максимального элемента массива, а указатель на него.<br />
<br />
==Указатели на указатель==<br />
Рассмотрим функцию поиска символа в строке, возвращающую позицию искомого элемента:<br />
<source lang="cpp"><br />
int findch (char *s, char p)<br />
{<br />
for (int i = 0; s[i] != 0; ++i)<br />
if (s[i] == p)<br />
return i;<br />
return -1;<br />
}<br />
</source><br />
Вообще данная функция должна информировать о двух вещах: во-первых, найден ли искомый символ, а во-вторых, если да, то его позицию. <br />
Будет правильно возвращать 2 значения соответственно, а не совмещать все в одном. Перепишем функцию:<br />
<source lang="cpp"><br />
bool findch (char *s, char p, int *n=0)<br />
{<br />
for (int i = 0; s[i] != 0; ++i)<br />
if (s[i] == p)<br />
{<br />
*n = i;<br />
return true;<br />
}<br />
return false;<br />
}<br />
</source><br />
Вызов: <br />
<source lang="cpp"><br />
int idx = 0;<br />
if (findch(s, ' ', &amp;idx)) {...}<br />
</source><br />
<br />
Чтобы возвращать не индекс элемента, а его позицию в массиве используют<br />
указатель на указатель:<br />
<source lang="cpp"><br />
bool findch (char *s, char p, char **pos=0)<br />
{<br />
while (*s!=0)<br />
{<br />
if (*s==p)<br />
{<br />
if (pos)<br />
*pos=s;<br />
return true;<br />
}<br />
++s;<br />
}<br />
return false;<br />
} <br />
</source><br />
Вызов:<br />
<source lang="cpp"><br />
char *pos = 0;<br />
if (findch(s, ' ', &amp;pos) {...}<br />
</source><br />
<br />
Работа с указательями напрямую синтаксически неудобна. Для достижения<br />
удобства используют ссылки:<br />
<source lang="cpp"><br />
int a = 5;<br />
int &amp;b = a; ''//b - ссылка на а''<br />
<br />
b = 10; ''//в а тоже стало 10''<br />
</source><br />
Функция swap с использованием ссылок будет выглядеть так:<br />
<source lang="cpp"><br />
void swap (int &amp;a, int &amp;b)<br />
{<br />
int t=b;<br />
b=a;<br />
a=t;<br />
}<br />
</source><br />
Вызов:<br />
<source lang="cpp"><br />
int c = 30;<br />
swap (a, c);<br />
</source><br />
При передаче параметров в функцию по ссылке копирования данных не<br />
происходит.<br />
<br />
===Различия ссылок и указателей===<br />
* Ссылку нельзя не проинициализировать (ссылка не может быть неинициализированной); ссылку нельзя переинициализировать.<br />
* Нельзя получить адрес ссылки или ссылку на ссылку.<br />
* Нельзя создавать массивы ссылок.<br />
<br />
''Замечание:''<br />
* &amp;q взятие адреса переменной q<br />
* *pa разименование<br />
* int &amp;a передача переменной а по ссылке<br />
* int *pa передача переменной по адресу.</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%A3%D0%BA%D0%B0%D0%B7%D0%B0%D1%82%D0%B5%D0%BB%D0%B8_%D0%B8_%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B8&diff=161Указатели и ссылки2011-03-30T07:56:57Z<p>Katepol: /* Указатели */</p>
<hr />
<div>==Указатели==<br />
Указатель - это переменная, содержащая адрес другой переменной. Указатели очень широко используются в языке С++. <br />
Это происходит отчасти потому, что иногда они дают единственную возможность выразить нужное действие, а отчасти потому, <br />
что они обычно ведут к более компактным и эффективным программам, чем те, которые могут быть написаны другими способами. <br />
Так как указатель содержит адрес объекта, это дает возможность "косвенного"<br />
доступа к этому объекту через указатель.<br />
<br />
Пример создания указателя на int и на double:<br />
<source lang="cpp"><br />
int a=5;<br />
int *pa = &amp;a;<br />
double d = 1.5;<br />
double *pd = &amp;d;<br />
<br />
pa = pd //нельзя! т.к. указатели на данные разного типа<br />
<br />
pa = (int*)pd; //компилируется<br />
</source><br />
<br />
Последняя операция лишена смысла, т.к. элемент типа double занимает 8 байт, а элемент типа int - 4 байта (в х32). <br />
Поэтому указатель pa будет указывать на первые 4 байта данных, расположенных по<br />
адресу, хранящемуся в pd.<br />
<br />
Рассмотрим пример функции, которая должна менять местами два значения:<br />
<source lang="cpp"><br />
void swap (int a, int b)<br />
{<br />
int t = a;<br />
a = b;<br />
b = t;<br />
}<br />
</source><br />
Вызов swap:<br />
<source lang="cpp"><br />
int k=10, m=20;<br />
swap (k, m);<br />
<br />
</source><br />
Несмотря на то, что все написано правильно, после возврата из функции swap значения k и m не изменились. Это обусловлено <br />
тем, что при передаче в функцию происходит копирование параметров. Таким образом, изменились скопированные значения, <br />
а исходные остались прежними. Чтобы иметь возможность менять параметры их следует передавать по указателю:<br />
<source lang="cpp"><br />
void swap (int *a, int *b)<br />
{<br />
int t = *a;<br />
*a = *b;<br />
*b = *t;<br />
}<br />
</source><br />
Вызов swap:<br />
<source lang="cpp"><br />
int k=10, m=20;<br />
swap (&amp;k, &amp;m);<br />
</source><br />
Теперь значения k и m изменились, так как при передаче в функцию произошло копирование адресов переменных, а адреса мы менять не хотели.<br />
<br />
==Встроенные массивы==<br />
'''Опр.''' Массив - это '''непрерывная''' область памяти, в которой<br />
расположены '''однотипные''' элементы.<br />
<br />
<source lang="cpp"><br />
int a[5] = {1, 2, 3}; ''//в памяти лежат 1,2,3,0,0''<br />
</source><br />
_ _ _ ___________________ _ _<br />
_ _ _ |_1_|_2_|_3_|_0_|_0_|_ _<br />
<br />
''Связь массивов и указателей:'' имя встроенного массива преобразуется в<br />
указатель (на первый элемент массива):<br />
<source lang="cpp"><br />
int *p = 0; ''//"нулевой" указатель, nil. Означает, что он не указывает ни на какую ячейку памяти.''<br />
p = a; ''// &amp;a[0]''<br />
<br />
a = p; ''// обратное (р = а) неверно''<br />
</source><br />
<br />
Передача массива в функцию в качестве параметра:<br />
<source lang="cpp"><br />
int max_element (int m[10]) {}<br />
</source><br />
<br />
''Массив передается по ссылке (не копируется).''<br />
Вызов: max_element(a);<br />
Функция max_element будет работать только с массивами из 10 элементов (с другими<br />
- не скомпилируется). Правильнее делать так:<br />
<source lang="cpp"><br />
int max_element (int *m, int size) <br />
{<br />
int max = *m; <br />
for (int i=1; i &amp;lt size; ++i)<br />
if (m[i] &amp;lt max)<br />
max = m[i];<br />
return max;<br />
}<br />
<br />
</source><br />
Вызов: max_element(a, 5); <br />
<br />
Проблемы такой реализации:<br />
* функция не работает с массивами нулевой длины;<br />
* не отследить случаи выхода за границы массива.<br />
<br />
===Арифметика указателей===<br />
Пусть q, p - указатели, а i - число. Возможные операции:<br />
* p+i, p-i сдвиг по массиву на i элементов вправо/влево<br />
* p[i] &lt;=&gt; *(p+i)<br />
* q-p количество элементов массива между p и q. Разность указателей имеет тип size_t.<br />
<br />
Рассмотрим две реализации функции подсчета длины символов в строке:<br />
<source lang="cpp"><br />
int strlen1 (char *s)<br />
{<br />
int len=0;<br />
while (s[len]!=0)<br />
++len;<br />
return len;<br />
}<br />
<br />
int strlen2 (char *s)<br />
{<br />
char *p = s;<br />
while (*p!=0)<br />
++p;<br />
return p-s;<br />
}<br />
</source><br />
<br />
Первая реализация более трудоемка, так как s[len] &lt;=&gt; *(s+len) то есть смещению по массиву и разименованию (2 операции), <br />
в то время, как во второй реализации мы работаем с указателями напрямую. Но второй вариант менее читабелен.<br />
Второй способ (работу с указателями напрямую) следует использовать и при<br />
передаче массива в функцию.<br />
<br />
Рекомендуется следующая сигнатура:<br />
<source lang="cpp"><br />
int foo (int *first, int *last);<br />
</source><br />
Где first является указателем на первый элемент массивва (a[0]), а last указателем на область памяти сразу за массивом ("a[n]"). <br />
Такой выбор указателя last обеспечивает работу с массивами нулевой длины.<br />
Перепишем функцию max_element:<br />
<source lang="cpp"><br />
int* max_element (int *m, int *last)<br />
{<br />
int *max = m;<br />
for (; m != last; ++m)<br />
if (*m &gt; *max)<br />
max = m;<br />
return max;<br />
}<br />
</source><br />
Вызов: max_element(a, a+5);<br />
Следует отметить, что теперь функция max_element возвращает не значение<br />
максимального элемента массива, а указатель на него.<br />
<br />
==Указатели на указатель==<br />
Рассмотрим функцию поиска символа в строке, возвращающую позицию искомого элемента:<br />
<source lang="cpp"><br />
int findch (char *s, char p)<br />
{<br />
for (int i = 0; s[i] != 0; ++i)<br />
if (s[i] == p)<br />
return i;<br />
return -1;<br />
}<br />
</source><br />
Вообще данная функция должна информировать о двух вещах: во-первых, найден ли искомый символ, а во-вторых, если да, то его позицию. <br />
Будет правильно возвращать 2 значения соответственно, а не совмещать все в одном. Перепишем функцию:<br />
<source lang="cpp"><br />
bool findch (char *s, char p, int *n=0)<br />
{<br />
for (int i = 0; s[i] != 0; ++i)<br />
if (s[i] == p)<br />
{<br />
*n = i;<br />
return true;<br />
}<br />
return false;<br />
}<br />
</source><br />
Вызов: <br />
<source lang="cpp"><br />
int idx = 0;<br />
if (findch(s, ' ', &amp;idx)) {...}<br />
</source><br />
<br />
Чтобы возвращать не индекс элемента, а его позицию в массиве используют<br />
указатель на указатель:<br />
<source lang="cpp"><br />
bool findch (char *s, char p, char **pos=0)<br />
{<br />
while (*s!=0)<br />
{<br />
if (*s==p)<br />
{<br />
if (pos)<br />
*pos=s;<br />
return true;<br />
}<br />
++s;<br />
}<br />
return false;<br />
} <br />
</source><br />
Вызов:<br />
<source lang="cpp"><br />
char *pos = 0;<br />
if (findch(s, ' ', &amp;pos) {...}<br />
</source><br />
<br />
Работа с указательями напрямую синтаксически неудобна. Для достижения<br />
удобства используют ссылки:<br />
<source lang="cpp"><br />
int a = 5;<br />
int &amp;b = a; ''//b - ссылка на а''<br />
<br />
b = 10; ''//в а тоже стало 10''<br />
</source><br />
Функция swap с использованием ссылок будет выглядеть так:<br />
<source lang="cpp"><br />
void swap (int &amp;a, int &amp;b)<br />
{<br />
int t=b;<br />
b=a;<br />
a=t;<br />
}<br />
</source><br />
Вызов:<br />
<source lang="cpp"><br />
int c = 30;<br />
swap (a, c);<br />
</source><br />
При передаче параметров в функцию по ссылке копирования данных не<br />
происходит.<br />
<br />
===Различия ссылок и указателей===<br />
* Ссылку нельзя не проинициализировать (ссылка не может быть неинициализированной); ссылку нельзя переинициализировать.<br />
* Нельзя получить адрес ссылки или ссылку на ссылку.<br />
* Нельзя создавать массивы ссылок.<br />
<br />
''Замечание:''<br />
* &amp;q взятие адреса переменной q<br />
* *pa разименование<br />
* int &amp;a передача переменной а по ссылке<br />
* int *pa передача переменной по адресу.</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%A3%D0%BA%D0%B0%D0%B7%D0%B0%D1%82%D0%B5%D0%BB%D0%B8_%D0%B8_%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B8&diff=160Указатели и ссылки2011-03-30T07:55:33Z<p>Katepol: Новая страница: «==Указатели== Указатель - это переменная, содержащая адрес другой переменной. Указатели оче…»</p>
<hr />
<div>==Указатели==<br />
Указатель - это переменная, содержащая адрес другой переменной. Указатели очень широко используются в языке С++. <br />
Это происходит отчасти потому, что иногда они дают единственную возможность выразить нужное действие, а отчасти потому, <br />
что они обычно ведут к более компактным и эффективным программам, чем те, которые могут быть написаны другими способами. <br />
Так как указатель содержит адрес объекта, это дает возможность "косвенного"<br />
доступа к этому объекту через указатель.<br />
<br />
Пример создания указателя на int и на double:<br />
<source lang="cpp"><br />
int a=5;<br />
int *pa = &amp;a;<br />
double d = 1.5;<br />
double *pd = &amp;d;<br />
<br />
pa = pd ''//нельзя! т.к. указатели на данные разного типа''<br />
<br />
pa = (int*)pd; ''//компилируется''<br />
</source><br />
<br />
Последняя операция лишена смысла, т.к. элемент типа double занимает 8 байт, а элемент типа int - 4 байта (в х32). <br />
Поэтому указатель pa будет указывать на первые 4 байта данных, расположенных по<br />
адресу, хранящемуся в pd.<br />
<br />
Рассмотрим пример функции, которая должна менять местами два значения:<br />
<source lang="cpp"><br />
void swap (int a, int b)<br />
{<br />
int t = a;<br />
a = b;<br />
b = t;<br />
}<br />
</source><br />
Вызов swap:<br />
<source lang="cpp"><br />
int k=10, m=20;<br />
swap (k, m);<br />
<br />
</source><br />
Несмотря на то, что все написано правильно, после возврата из функции swap значения k и m не изменились. Это обусловлено <br />
тем, что при передаче в функцию происходит копирование параметров. Таким образом, изменились скопированные значения, <br />
а исходные остались прежними. Чтобы иметь возможность менять параметры их следует передавать по указателю:<br />
<source lang="cpp"><br />
void swap (int *a, int *b)<br />
{<br />
int t = *a;<br />
*a = *b;<br />
*b = *t;<br />
}<br />
</source><br />
Вызов swap:<br />
<source lang="cpp"><br />
int k=10, m=20;<br />
swap (&amp;k, &amp;m);<br />
</source><br />
Теперь значения k и m изменились, так как при передаче в функцию произошло копирование адресов переменных, а адреса мы менять не хотели. <br />
<br />
==Встроенные массивы==<br />
'''Опр.''' Массив - это '''непрерывная''' область памяти, в которой<br />
расположены '''однотипные''' элементы.<br />
<br />
<source lang="cpp"><br />
int a[5] = {1, 2, 3}; ''//в памяти лежат 1,2,3,0,0''<br />
</source><br />
_ _ _ ___________________ _ _<br />
_ _ _ |_1_|_2_|_3_|_0_|_0_|_ _<br />
<br />
''Связь массивов и указателей:'' имя встроенного массива преобразуется в<br />
указатель (на первый элемент массива):<br />
<source lang="cpp"><br />
int *p = 0; ''//"нулевой" указатель, nil. Означает, что он не указывает ни на какую ячейку памяти.''<br />
p = a; ''// &amp;a[0]''<br />
<br />
a = p; ''// обратное (р = а) неверно''<br />
</source><br />
<br />
Передача массива в функцию в качестве параметра:<br />
<source lang="cpp"><br />
int max_element (int m[10]) {}<br />
</source><br />
<br />
''Массив передается по ссылке (не копируется).''<br />
Вызов: max_element(a);<br />
Функция max_element будет работать только с массивами из 10 элементов (с другими<br />
- не скомпилируется). Правильнее делать так:<br />
<source lang="cpp"><br />
int max_element (int *m, int size) <br />
{<br />
int max = *m; <br />
for (int i=1; i &amp;lt size; ++i)<br />
if (m[i] &amp;lt max)<br />
max = m[i];<br />
return max;<br />
}<br />
<br />
</source><br />
Вызов: max_element(a, 5); <br />
<br />
Проблемы такой реализации:<br />
* функция не работает с массивами нулевой длины;<br />
* не отследить случаи выхода за границы массива.<br />
<br />
===Арифметика указателей===<br />
Пусть q, p - указатели, а i - число. Возможные операции:<br />
* p+i, p-i сдвиг по массиву на i элементов вправо/влево<br />
* p[i] &lt;=&gt; *(p+i)<br />
* q-p количество элементов массива между p и q. Разность указателей имеет тип size_t.<br />
<br />
Рассмотрим две реализации функции подсчета длины символов в строке:<br />
<source lang="cpp"><br />
int strlen1 (char *s)<br />
{<br />
int len=0;<br />
while (s[len]!=0)<br />
++len;<br />
return len;<br />
}<br />
<br />
int strlen2 (char *s)<br />
{<br />
char *p = s;<br />
while (*p!=0)<br />
++p;<br />
return p-s;<br />
}<br />
</source><br />
<br />
Первая реализация более трудоемка, так как s[len] &lt;=&gt; *(s+len) то есть смещению по массиву и разименованию (2 операции), <br />
в то время, как во второй реализации мы работаем с указателями напрямую. Но второй вариант менее читабелен.<br />
Второй способ (работу с указателями напрямую) следует использовать и при<br />
передаче массива в функцию.<br />
<br />
Рекомендуется следующая сигнатура:<br />
<source lang="cpp"><br />
int foo (int *first, int *last);<br />
</source><br />
Где first является указателем на первый элемент массивва (a[0]), а last указателем на область памяти сразу за массивом ("a[n]"). <br />
Такой выбор указателя last обеспечивает работу с массивами нулевой длины.<br />
Перепишем функцию max_element:<br />
<source lang="cpp"><br />
int* max_element (int *m, int *last)<br />
{<br />
int *max = m;<br />
for (; m != last; ++m)<br />
if (*m &gt; *max)<br />
max = m;<br />
return max;<br />
}<br />
</source><br />
Вызов: max_element(a, a+5);<br />
Следует отметить, что теперь функция max_element возвращает не значение<br />
максимального элемента массива, а указатель на него.<br />
<br />
==Указатели на указатель==<br />
Рассмотрим функцию поиска символа в строке, возвращающую позицию искомого элемента:<br />
<source lang="cpp"><br />
int findch (char *s, char p)<br />
{<br />
for (int i = 0; s[i] != 0; ++i)<br />
if (s[i] == p)<br />
return i;<br />
return -1;<br />
}<br />
</source><br />
Вообще данная функция должна информировать о двух вещах: во-первых, найден ли искомый символ, а во-вторых, если да, то его позицию. <br />
Будет правильно возвращать 2 значения соответственно, а не совмещать все в одном. Перепишем функцию:<br />
<source lang="cpp"><br />
bool findch (char *s, char p, int *n=0)<br />
{<br />
for (int i = 0; s[i] != 0; ++i)<br />
if (s[i] == p)<br />
{<br />
*n = i;<br />
return true;<br />
}<br />
return false;<br />
}<br />
</source><br />
Вызов: <br />
<source lang="cpp"><br />
int idx = 0;<br />
if (findch(s, ' ', &amp;idx)) {...}<br />
</source><br />
<br />
Чтобы возвращать не индекс элемента, а его позицию в массиве используют<br />
указатель на указатель:<br />
<source lang="cpp"><br />
bool findch (char *s, char p, char **pos=0)<br />
{<br />
while (*s!=0)<br />
{<br />
if (*s==p)<br />
{<br />
if (pos)<br />
*pos=s;<br />
return true;<br />
}<br />
++s;<br />
}<br />
return false;<br />
} <br />
</source><br />
Вызов:<br />
<source lang="cpp"><br />
char *pos = 0;<br />
if (findch(s, ' ', &amp;pos) {...}<br />
</source><br />
<br />
Работа с указательями напрямую синтаксически неудобна. Для достижения<br />
удобства используют ссылки:<br />
<source lang="cpp"><br />
int a = 5;<br />
int &amp;b = a; ''//b - ссылка на а''<br />
<br />
b = 10; ''//в а тоже стало 10''<br />
</source><br />
Функция swap с использованием ссылок будет выглядеть так:<br />
<source lang="cpp"><br />
void swap (int &amp;a, int &amp;b)<br />
{<br />
int t=b;<br />
b=a;<br />
a=t;<br />
}<br />
</source><br />
Вызов:<br />
<source lang="cpp"><br />
int c = 30;<br />
swap (a, c);<br />
</source><br />
При передаче параметров в функцию по ссылке копирования данных не<br />
происходит.<br />
<br />
===Различия ссылок и указателей===<br />
* Ссылку нельзя не проинициализировать (ссылка не может быть неинициализированной); ссылку нельзя переинициализировать.<br />
* Нельзя получить адрес ссылки или ссылку на ссылку.<br />
* Нельзя создавать массивы ссылок.<br />
<br />
''Замечание:''<br />
* &amp;q взятие адреса переменной q<br />
* *pa разименование<br />
* int &amp;a передача переменной а по ссылке<br />
* int *pa передача переменной по адресу.</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%9A%D0%BE%D0%BD%D1%81%D0%BF%D0%B5%D0%BA%D1%82%D1%8B_%D0%A1%2B%2B&diff=159Конспекты С++2011-03-30T07:44:29Z<p>Katepol: </p>
<hr />
<div>Конспекты по C++<br />
* [[ Как происходит компиляция|Как происходит компиляция. Алексей Давыдов. 08.09.2010]]<br />
* [[ Указатели и ссылки|Указатели и ссылки. Екатерина Полищук. 10.09.2010]]<br />
* [[ Динамическое распределение памяти|Динамическое распределение памяти. Алексей Гуревич. 17.09.2010]]<br />
* [[ Перегрузка операторов|Перегрузка операторов. Мария Фомкина. 12.11.2010]]<br />
* [[ STL. Последовательные контейнеры|STL. Последовательные контейнеры. Мария Фомкина. 18.02.2011]]</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%9A%D0%BE%D0%BD%D1%81%D0%BF%D0%B5%D0%BA%D1%82%D1%8B_%D0%A1%2B%2B&diff=158Конспекты С++2011-03-30T07:43:52Z<p>Katepol: </p>
<hr />
<div>Конспекты по C++<br />
* [[ Как происходит компиляция|Как происходит компиляция. Алексей Давыдов. 08.09.2010]]<br />
* [[ Указатели|Указатели. Екатерина Полищук. 10.09.2010]]<br />
* [[ Динамическое распределение памяти|Динамическое распределение памяти. Алексей Гуревич. 17.09.2010]]<br />
* [[ Перегрузка операторов|Перегрузка операторов. Мария Фомкина. 12.11.2010]]<br />
* [[ STL. Последовательные контейнеры|STL. Последовательные контейнеры. Мария Фомкина. 18.02.2011]]</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%97%D0%B0%D0%B4%D0%B0%D0%BD%D0%B8%D1%8F_%D0%BF%D0%BE_%D0%A1%2B%2B&diff=156Задания по С++2011-03-30T07:34:03Z<p>Katepol: /* Лабораторная работа №5 functor */</p>
<hr />
<div>== Лабораторная работа №1 Шаблоны ==<br />
Реализовать собственный контейнер <br />
<source lang="cpp">template<typename T><br />
class Container {<br />
public:<br />
void push_back(const T& t);<br />
T& back();<br />
size_t size() const;<br />
};</source><br />
В качестве хранилища значенией в реализации <code>Container</code> используйте <code>std::vector</code>.<br />
<br />
Затем создайте новый контейнер с двумя шаблонными параметрами, первый - тип хранимых значений, второй - тип хранилища, используемый в реализации вашего контейнера.<br />
<br />
Пример использования такого контейнера<br />
<source lang="cpp"><br />
Container<int, std::list<int> > c;<br />
</source><br />
<br />
Затем создайте новый контейнер с двумя шаблонными параметрами, первый - тип хранимых значений, второй - шаблон, используемый в реализации вашего контейнера.<br />
<br />
Пример использования такого контейнера<br />
<source lang="cpp"><br />
Container<int, std::deque> c;<br />
</source><br />
<br />
== Лабораторная работа №2 Синглтон ==<br />
<br />
Написать протой логгер<br />
<source lang="cpp">class Logger {<br />
public:<br />
void warn(const std::string& msg);<br />
static Logger& getInstance();<br />
};<br />
</source><br />
Запретить пользователю его создание, копирование.<br />
<br />
Пример использования<br />
<source lang="cpp"><br />
Logger& log = Logger::getInstance();<br />
log.warn("Ooops");<br />
</source><br />
<br />
Представить, что понадобилось ещё несколько синглтонов, вынести общий для всех синглтонов код в отдельный класс <code>Singleton</code>.<br />
Реализовать логгер с использованием класса <code>Singleton</code> так, чтоб код, использующий логгер, не надо было модифицировать.<br />
<br />
== Лабораторная работа №3 merge sort ==<br />
Необходимо написать функцию сортировки слиянием.<br /><br />
Сигнатура функции должны быть такой:<br /><br />
<source lang="cpp">template<typename Iter><br />
std::list<typename Iter::value_type> mergeSort(Iter left, Iter right);</source><br /><br />
Исходные данные функция модифицировать не должна, в возвращаемом списке должны быть отсортированные элементы.<br />
<br />
Затем необходимо добиться, чтоб можно было сортировать по указателям:<br /><br />
<source lang="cpp">int* array = new int[SIZE];<br />
mergeSort(array, array + SIZE);</source><br />
<br />
''Рекомендации'': для merge можно воспользоваться <code>std::list::merge</code><br /><br />
для получения типа, на который указывает указатель, можно воспользоваться <code>std::iterator_traits</code><br />
<br />
== Лабораторная работа №4 iterator ==<br />
Написать наблонный класс <code>slist</code> односвязный список.<br /><br />
Реализовать для него <code>forward</code> итератор.<br />
<br />
<br />
== Лабораторная работа №5 functor ==<br />
Реализовать алгоритм <br />
<source lang="cpp"><br />
template<typename InIter, typename OutIter, typename Pred><br />
OutIter filter(InIter begin, InIter end, OutIter out, Pred pred);<br />
</source><br />
который читает элементы и, если <code>pred(val)</code> возвращает <code>true</code>, то записывает элемент в <code>out</code>.<br />
<br />
Реализовать собственный функтор, который принимает <code>std::set<char></code> и <code>char</code> и проверят наличие входного символа в сете.<br />
С помощью алгоритма <code>filter</code> и вашего функтора отфильровать строку.<br />
<br />
== Лабораторная работа №6 mem_fun ==<br />
Реализовать аналог <code>std::mem_fun</code>, убедиться, что аналог работает на коде:<br />
<source lang="cpp"><br />
std::vector<char> v;<br />
std::set<int> s;<br />
mem_fun(&std::vector<char>::push_back)(v, 'd');<br />
mem_fun(&std::set<int>::count)(s, 3);<br />
</source><br />
<br />
<br />
== Лабораторная работа №7 заполнитель мапы ==<br />
Реализовать заполнитель мапы<br />
<source lang="cpp"><br />
std::map<float, int> m(mapper(1.0, 2)(2, 2)(4, 2));<br />
</source></div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%90%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7_%D0%B8%D0%B7%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D0%B9_%D1%81_%D1%86%D0%B5%D0%BB%D1%8C%D1%8E_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0_%D0%BF%D0%BE%D1%85%D0%BE%D0%B6%D0%B8%D1%85_%D0%BB%D0%B8%D1%86&diff=102Анализ изображений с целью поиска похожих лиц2011-03-15T18:23:39Z<p>Katepol: </p>
<hr />
<div>* Студент: Екатерина Полищук<br />
<br />
* Руководитель: Екатерина Тузова<br />
<br />
Описание: целью проекта является разработка приложения, реализующего автоматическую локализацию лица на фотографии и идентификацию персоны по лицу. В дальнейшем спецификация будет уточнена.<br />
<br />
Этапы:<br />
* концепция приложения (20.03.2011)<br />
* прототип приложения (альфа версия) (25.04.2011)<br />
* бета версия приложения, итог (25.05.2011)<br />
<br />
Ожидаемый результат:<br />
* приложение, опубликованное на http://code.google.com/</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%90%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7_%D0%B8%D0%B7%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D0%B9_%D1%81_%D1%86%D0%B5%D0%BB%D1%8C%D1%8E_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0_%D0%BF%D0%BE%D1%85%D0%BE%D0%B6%D0%B8%D1%85_%D0%BB%D0%B8%D1%86&diff=98Анализ изображений с целью поиска похожих лиц2011-03-15T17:58:12Z<p>Katepol: </p>
<hr />
<div>* Студент: Екатерина Полищук<br />
<br />
* Руководитель: Екатерина Тузова<br />
<br />
Описание: целью проекта является разработка приложения, реализующего автоматическую локализацию лица на фотографии и идентификация персоны по лицу. В дальнейшем спецификация будет уточнена.<br />
<br />
Этапы:<br />
* концепция приложения (20.03.2011)<br />
* прототип приложения (альфа версия) (25.04.2011)<br />
* бета версия приложения, итог (25.05.2011)<br />
<br />
Ожидаемый результат:<br />
* приложение, опубликованное на http://code.google.com/</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%90%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7_%D0%B8%D0%B7%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D0%B9_%D1%81_%D1%86%D0%B5%D0%BB%D1%8C%D1%8E_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0_%D0%BF%D0%BE%D1%85%D0%BE%D0%B6%D0%B8%D1%85_%D0%BB%D0%B8%D1%86&diff=75Анализ изображений с целью поиска похожих лиц2011-03-12T21:00:30Z<p>Katepol: Новая страница: «* Студент: Екатерина Полищук * Руководитель: Екатерина Тузова Описание: целью проекта явл…»</p>
<hr />
<div>* Студент: Екатерина Полищук<br />
<br />
* Руководитель: Екатерина Тузова<br />
<br />
Описание: целью проекта является разработка приложения, реализующего автоматическую локализация лица на фотографии и идентификация персоны по лицу. В дальнейшем спецификация будет уточнена.<br />
<br />
Этапы:<br />
* концепция приложения (20.03.2011)<br />
* прототип приложения (альфа версия) (25.04.2011)<br />
* бета версия приложения, итог (25.05.2011)<br />
<br />
Ожидаемый результат:<br />
* приложение, опубликованное на http://code.google.com/</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%A2%D0%B5%D0%BC%D1%8B_%D0%BF%D1%80%D0%B0%D0%BA%D1%82%D0%B8%D0%BA&diff=74Темы практик2011-03-12T20:48:46Z<p>Katepol: /* Весна 2011 */</p>
<hr />
<div>На этой странице собраны темы индивидуальных и командных проектов. <br />
<br />
== Весна 2011 ==<br />
<br />
* [[Genome assembler]] (Mariya Fomkina)<br />
<br />
* [[Анализ изображений с целью поиска похожих лиц]] (Екатерина Полищук)<br />
<br />
== Пул свободных тем ==<br />
<br />
* [[GeoToDo list]]</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D1%86%D0%B0:Katepol&diff=73Участница:Katepol2011-03-11T07:33:28Z<p>Katepol: /* Екатерина Полищук */</p>
<hr />
<div>== Екатерина Полищук ==<br />
<br />
mailto: katepol14@gmail.com<br />
<br />
[[Файл:Kate1.jpg]]</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D1%86%D0%B0:Katepol&diff=72Участница:Katepol2011-03-11T07:32:48Z<p>Katepol: /* Екатерина Полищук */</p>
<hr />
<div>== Екатерина Полищук ==<br />
<br />
[[katepol14@gmail.com]]<br />
<br />
[[Файл:Kate1.jpg]]</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D1%86%D0%B0:Katepol&diff=71Участница:Katepol2011-03-11T07:32:07Z<p>Katepol: /* Екатерина Полищук */</p>
<hr />
<div>== Екатерина Полищук ==<br />
<br />
katepol14@gmail.com<br />
<br />
[[Файл:Kate1.jpg]]</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D1%86%D0%B0:Katepol&diff=70Участница:Katepol2011-03-11T07:31:24Z<p>Katepol: /* Екатерина Полищук */</p>
<hr />
<div>== Екатерина Полищук ==<br />
<br />
katepol14@gmail.com<br />
[[Файл:Kate1.jpg]]</div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%A4%D0%B0%D0%B9%D0%BB:Kate1.jpg&diff=69Файл:Kate1.jpg2011-03-11T07:30:18Z<p>Katepol: загружена новая версия «Файл:Kate1.jpg»</p>
<hr />
<div></div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%A4%D0%B0%D0%B9%D0%BB:Kate1.jpg&diff=68Файл:Kate1.jpg2011-03-11T07:28:18Z<p>Katepol: </p>
<hr />
<div></div>Katepolhttp://mit.spbau.ru/sewiki/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D1%86%D0%B0:Katepol&diff=67Участница:Katepol2011-03-11T07:27:32Z<p>Katepol: Новая страница: «== Екатерина Полищук == katepol14@gmail.com Файл:/home/kate/Pictures/kate1.jpg»</p>
<hr />
<div>== Екатерина Полищук ==<br />
<br />
katepol14@gmail.com<br />
[[Файл:/home/kate/Pictures/kate1.jpg]]</div>Katepol