Прикладное программирование

4.1 Структуры

4.1.1. Пример 4.1. Структура для работы с компонентами цвета

Структура – это объединение нескольких компонентов в переменную с одним именем.

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

/////////////////////////////////////////////////////////////////////////////
// Прикладное программирование
// Пример 4.1. Cтруктура для работы с компонентами цвета
// color.h
// 
// Кафедра Прикладной и компьютерной оптики, http://aco.ifmo.ru
// Университет ИТМО
/////////////////////////////////////////////////////////////////////////////
// Структура для работы с компонентами цвета
struct color
{
    // описание красной, зеленой, и синей компоненты цвета. Диапазон значений - от 0 до 255
    int red, green, blue;
}; 
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
// Прикладное программирование
// Пример 4.1. Cтруктура для работы с компонентами цвета
// test_color.cpp
// 
// Кафедра Прикладной и компьютерной оптики, http://aco.ifmo.ru
// Университет ИТМО
/////////////////////////////////////////////////////////////////////////////
#include <iostream>
using namespace std;

// подключение описания структуры
#include "color.h"
/////////////////////////////////////////////////////////////////////////////
// описание фукнций вычисления яркости:
// функция вычисления яркости, экземпляр структуры color передается по значению
int luminance1(color c);
// функция вычисления яркости, экземпляр структуры color передается по ссылке
int luminance2(color& c);
// функция вычисления яркости, экземпляр структуры color передается по указателю
int luminance3(color* c);
/////////////////////////////////////////////////////////////////////////////
void main()
{
    // объявление экземпляра WhiteColor структуры color
    // color используется как новый тип данных
    color WhiteColor; 

    // переменная для хранения цвета инициализирована белым цветом
    // доступ к переменным-членам осуществляется по оператору "."
    WhiteColor.red=255;   
    WhiteColor.green=255; 
    WhiteColor.blue=255; 

    // получения значения компоненты красного цвета и вывод его на экран
    int x=WhiteColor.red;
    cout<<x<<endl;

    //------------------------------------------------------------------------
    // динамическое размещение структуры
    // RedColor - указатель на экземпляр структуры color
    color* RedColor=new color; 

    // если объявлен указатель на экземпляр стурктуры, 
    // доступ к переменным-членам осуществляется по оператору "->"
    RedColor->red=255; 
    RedColor->green=0; 
    // или при помощи оператора разыменования и оператора "."
    (*RedColor).blue=0; 

    // получение указателя на переменную-член структуры
    int* green=&RedColor->green; 
    int* red=&WhiteColor.red;
    // вывод на экран указателя и значения по указателю
    cout<<red<<" "<<*red<<"    "<<green<<" "<<*green<<endl;

    // изменение переменной-члена по указателю на нее
    *red=55;
    cout<<WhiteColor.red<<endl;

    //------------------------------------------------------------------------
    // вывод на экран яркости, вычисленной при помощи различных функций
    cout<<luminance1(WhiteColor)<<endl;
    cout<<luminance2(WhiteColor)<<endl;
    cout<<luminance3(&WhiteColor)<<endl;   
}
/////////////////////////////////////////////////////////////////////////////
// функция вычисления яркости, экземпляр структуры color передается по значению
int luminance1(color c)
{
    return 0.212*c.red + 0.715*c.green + 0.072*c.blue;
}
/////////////////////////////////////////////////////////////////////////////
// функция вычисления яркости, экземпляр структуры color передается по ссылке
int luminance2(color& c)
{
    return 0.212*c.red + 0.715*c.green + 0.072*c.blue;
}
/////////////////////////////////////////////////////////////////////////////
// функция вычисления яркости, экземпляр структуры color передается по указателю
int luminance3(color* c)
{
    return 0.212*c->red + 0.715*c->green + 0.072*c->blue;
}
/////////////////////////////////////////////////////////////////////////////

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

color WhiteColor;

Для доступа к членам структуры используется оператор ".".

WhiteColor.red=255; 
WhiteColor.green=255; 
WhiteColor.blue=255;

Абстрактные типы данных, также как и встроенные типы, можно размещать статически и динамически:

// динамическое размещение структуры 
color * RedColor = new color ;

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

// если объявлен указатель на экземпляр структуры, 
// доступ к переменным-членам осуществляется по оператору "->" 
RedColor -> red =255; 
// или при помощи оператора разыменования и оператора "." 
(*RedColor).blue=0;

4.1.2. Передача абстрактных типов в функцию

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

/////////////////////////////////////////////////////////////////////////////
// функция вычисления яркости, экземпляр структуры color передается по значению
int luminance1(color c)
{
    return 0.212*c.red + 0.715*c.green + 0.072*c.blue;
}
/////////////////////////////////////////////////////////////////////////////
// функция вычисления яркости, экземпляр структуры color передается по ссылке
int luminance2(color& c)
{
    return 0.212*c.red + 0.715*c.green + 0.072*c.blue;
}
/////////////////////////////////////////////////////////////////////////////
// функция вычисления яркости, экземпляр структуры color передается по указателю
int luminance3(color* c)
{
    return 0.212*c->red + 0.715*c->green + 0.072*c->blue;
}
/////////////////////////////////////////////////////////////////////////////

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

int luminance2(const color& c)

По значению абстрактные типы данных обычно не передаются, для экономии времени на копирование данных, и для экономии памяти на размещение данных.

4.1.3. Создание функций-членов для абстрактного типа данных. Пример 4.2. Структура для работы с компонентами цвета со встроенной функцией.

Абстрактные типы данных можно снабдить своими собственными функциями для обработки своего содержимого. Например, функцию luminance можно сделать членом структуры color. Для вызова этой функции-члена структуры color нужно использовать операторы доступа . или ->, так же как и для доступа к членам-переменным:

int l=x.luminance();

При этом экземпляр x структуры color не надо дополнительно передавать в функцию, поскольку функция luminance будет автоматически иметь доступ ко всем переменным-членам структуры.

/////////////////////////////////////////////////////////////////////////////
// Прикладное программирование
// Пример 4.2. Структура для работы с компонентами цвета со встроенной функцией
// color2.h
// 
// Кафедра Прикладной и компьютерной оптики, http://aco.ifmo.ru
// Университет ИТМО
/////////////////////////////////////////////////////////////////////////////
// Структура для работы с компонентами цвета со встроенной функцией
struct color2
{
    // описание красной, зеленой, и синей компоненты цвета. Диапазон значений - от 0 до 255
    int red, green, blue;

    // функция вычисления яркости
    int luminance()
    {
        return int(0.212*red + 0.715*green + 0.072*blue);
    }
};
/////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
// Прикладное программирование
// Пример 4.2. Структура для работы с компонентами цвета со встроенной функцией
// test_color2.cpp
// 
// Кафедра Прикладной и компьютерной оптики, http://aco.ifmo.ru
// Университет ИТМО
/////////////////////////////////////////////////////////////////////////////
#include <iostream>
using namespace std;

// подключение описания структуры
#include "color2.h"
/////////////////////////////////////////////////////////////////////////////
void main()
{
    // объявление экземпляра GrayColor структуры color
    // color используется как новый тип данных
    color2 GrayColor; 

    // переменная для хранения цвета инициализирована серым цветом
    GrayColor.blue=100;
    GrayColor.red=100;
    GrayColor.green=100;

    // вычисление яркости при помощи фукнции-члена структуры
    // доступ к функциям-членам осуществляется по оператору "."
    cout<<GrayColor.luminance()<<endl;  

    // объявление указателя на экземпляр структуры color
    color2 *pColor=&GrayColor;

    // если объявлен указатель на экземпляр стурктуры, 
    // доступ к функциям-членам осуществляется по оператору "->"
    cout<<pColor->luminance()<<endl; // если y – указатель на структуру
}
/////////////////////////////////////////////////////////////////////////////