WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!


Pages:     | 1 |   ...   | 5 | 6 || 8 | 9 |   ...   | 11 |

p->city="Moscow";

gruppa[0].num=12;

Прежде всего, структура – это тип данных, определяемый программистом. Для объявления структуры используется ключевое слово struct, за которым записывается имя структуры. В блоке, выделенном фигурными скобками, объявляются элементы структуры. После закрывающей фигурной скобки обязательно ставится точка с запятой – объявление структуры является оператором. Можно создавать переменные и массивы структурного типа, объявлять функции, возвращающие значения типа структуры и передавать параметры в виде структур. В примере объявлены переменная drug и массив gruppa, имеющие тип структуры Address, а также переменная p – указатель на структуру.

В языке C ключевое слово struct необходимо использовать и при объявлении переменных (см., напр., Керниган Б.В., Ричи Д.М. Язык программирования C.) struct Address drug;

struct Address *p=new Address;

struct Address gruppa[10];

В языке C++ эта форма объявления также допустима.

Для доступа к элементам структуры используется. – оператор доступа к элементу структуры, или, просто оператор точка. Для доступа к элементам структуры с помощью указателя используется оператор стрелки –> (состоит из знаков минус и :>).

Из ранних версий языка C осталась еще одна форма объявления – с помощью typedef typedef struct Address { char name[40];

int num; // номер дома char *street; // улица char *city; // город int zip; // индекс };

Ключевое слово typedef можно использовать для создания псевдонимов (алиасов) уже объявленных типов (и не только структур).

Пример. Создаются псевдонимы address и ADDRESS структуры Address. Кроме того, для типа int создан псевдоним I.

typedef struct Address { char *street; // улица char *city; // город } address; //псевдоним typedef struct Address ADDRESS; // еш один псевдоним typedef int I; // псевдоним для int Address drug;

address my;

ADDRESS work;

my.city="Kazan";

I n=2012;

cout<<"\n n="<

tricol svetophor; // или enum tricol svetophor;

svetophor=green;

int m;

cout<<"\n m=0,1,2 \n"; cin>>m;

switch (m){ case red: cout<<"\nКрасный"; break;

case yellow: cout<<"\nЖелтый"; break;

case green: cout<<"\nЗеленый"; break;

default: cout<<"\nНеопределено";

} Каждый элемент перечислений на самом деле является целым числом, первый элемент списка перечислений имеет значение 0, следующий равен и т.д. Можно явно указать значения элементов перечисления, как показано в следующем примере.

Пример. Использование инициализаторов. Перечислители, идущие в списке за инициализатором получают следующие по порядку значения.

enum TypeFiles {txt=10, doc=100, pdf=200, exe};

TypeFiles tf=exe;

cout<<"\n tf= "<

Функции Разделение программы на отдельные логические блоки – функции, позволяет эффективнее управлять кодом.

Использование функции предполагает:

– объявление функции (е прототип), включающее имя функции, тип возвращаемого ею значения и типы параметров функции;

– определение функции, включающее заголовок функции и последовательность операторов, реализующих функцию;

– вызов функции путем указания ее имени и заменой формальных параметров значениями (фактическими параметрами).

Пример. Пример использования функции.

#include using namespace std;

int sum(int, int);/* Объявление функции - прототип */ int main() { int a,b,c;

cout << "Vvodim: ";

cin >> a >> b;

c=sum(a, b); // Вызов функции cout << "\n sum = " << c;

return 0;

} int sum(int a, int b) { // Определение функции return a+b;

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

Возвращаемый_тип Имя_функции(список типов_параметров);

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



Пример. Блок определения функции предшествует е вызову, поэтому в программе нет объявления функции (прототипа).

#include using namespace std;

int sum(int a, int b) { // Определение функции return a+b;

} int main() { int a,b,c;

cout << "Vvodim: ";

cin >> a >> b;

c=sum(a, b); // Вызов функции cout << "\n c = " << c;

return 0;

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

Часто прототипы функций помещают в отдельные файлы – заголовочные файлы (эти файлы имеют расширение.h).

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

Функция должна содержать хотя бы один оператор return – исключением являются функции, у которых тип возвращаемых значений void. Выполнение оператора return завершает работу функции и возвращает управление в вызывающую программу. Синтаксис оператора return выражение;

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

return;

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

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

Пример. Метод итераций решения уравнений y=g(x). Приближенное решение вычисляется с точностью, заданной значением переменной e.

// Метод итераций.

// #include "stdafx.h" #include #include using namespace std;

const int NMax=1000; // Макс. число шагов метода double g(double);// Прототип int _tmain(int argc, _TCHAR* argv[]) { double x, x0, y, d, e;

int k;

e = 1.e-5; // Точность // Начальное приближение:

x = x0 = 2.5;

k = 1;

// Метод итерации:

do { y = g(x); // Вызов функции d = fabs(y-x);

k++;

x = y;

} while ((d>e) && (k

cout<<"\nx= "<

return 0;

} double g(double x) // Определение функции { // Значение правой части x=g(x) return - x * x * x * 0.04 + 1.08 * x + 0.2;

} Пример. Реализацию алгоритмов, как правило, оформляют в виде функций, а в функцию main() помещают только вызовы этих функций.

Следующий код является такой модификацией предыдущего примера.

// Метод итераций // #include "stdafx.h" #include #include using namespace std;

const int NMax=1000; // Макс. число шагов метода // Прототипы функций:

double g(double);

double iterat(double, double, int * );

int _tmain(int argc, _TCHAR* argv[]) { setlocale(LC_CTYPE, "rus"); // русификация консоли double y;

int n;

y=iterat(2.5,1.e-5,&n);// Вызов функции cout<<"\nЗа "<

return 0;

} double g(double x) // Определение функции { // Значение правой части x=g(x) return - x * x * x * 0.04 + 1.08 * x + 0.2;

} double iterat(double x,double e, int * k) { double y;

double d;

// Метод итерации:

*k =1;

do { y = g(x);

d = fabs(y-x);

(*k)++;

x = y;

} while ((d>e) && ((*k)

return y;

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

Пример. Вариант функции обмена в синтаксисе языка C.

#include using namespace std;

void swapargs(int * px, int * py);

int main() { int i, j;

i = 10; j = 19;

cout << "i: " << i << ", ";

cout << "j: " << j << "\n";

swapargs(&i, &j);

cout << "После перестановки: ";

cout << "i: " << i << ", ";

cout << "j: " << j << "\n";

return 0;

} void swapargs(int * px, int * py) { int t;

t = *px; *px = *py; *py = t;

} Ссылочные переменные В языке C++ введн новый составной тип данных – ссылочная переменная. Ссылка представляет собой имя, которое является псевдонимом для ранее объявленной переменной. Для объявления ссылочной переменной используется символ &‘.

Пример.

#include using namespace std;

int main() { int x;

int &r = x; // создание независимой ссылки x = 10; // эти две инструкции r = 10; // идентичны r = 100; // x=100;

// здесь дважды печатается число cout << x << '\t'<< r <<"\n";

return 0;

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





Пример. Стандартный пример передачи аргументов по ссылке – функция, меняющая значения аргументов #include using namespace std;

void swapargs(int &x, int &y);

int main() { int i, j;

i = 10;

j = 19;

cout << "i: " << i << ", ";

cout << "j: " << j << "\n";

swapargs(i, j);

cout << "После перестановки: ";

cout << "i: " << i << ", ";

cout << "j: " << j << "\n";

return 0;

} void swapargs(int &x, int &y) { int t;

t = x; x = y; y = t;

} Пример. Ещ один пример на передачу параметров. Используется и ссылка и указатель.

#include using namespace std;

void rneg(int &i); // версия со ссылкой void pneg(int *i); // версия с указателем int main() { int i = 10;

int j = 20;

rneg(i);

pneg(&j);

cout << i << ' ' << j << '\n';

return 0;

} // использование параметра-ссылки void rneg(int &i) { i = - i; } // использование параметра-указателя void pneg(int *i) { *i = -*i; } Указатели на функцию Функции, как и переменные, имеют адреса. Адресом функции является адрес памяти, с которого начинается машинный код функции.

Пример. Еще один вариант реализации метода итераций – в число параметров включена функция (правая часть уравнения y=g(x)). Кроме того, приближенное решение, вычисленное функцией iterat(), также возвращается с помощью параметра.

// Метод итераций.

#include "stdafx.h" #include #include using namespace std;

const int NMax=1000; // Макс. число шагов метода // Прототипы функций:

double g(double);

void iterat(double (*)(double),double, double, double*, int*);

int _tmain(int argc, _TCHAR* argv[]) { double y;

int n;

iterat(g,2.5,1.e-5,&y,&n);// Вызов функции cout<<"\ny= "<

return 0;

} double g(double x) // Определение функции { // Значение правой части x=g(x) return - x * x * x * 0.04 + 1.08 * x + 0.2;

} void iterat(double (*g)(double),double x, double e, double * y, int * k) { double d;

// Метод итерации:

*k =1;

do { *y = g(x);

d = fabs(*y-x);

(*k)++;

x = *y;

} while ((d>e) && ((*k)

} Пример. Функция myoperator() способна выполнить любую операцию с двумя целыми числами, – эта операция задается третьим параметром (см. также Прата С. Язык программирования C++. ).

int plus(int,int);

int minus (int,int);

int myoperator (int x, int y, int (*f)(int,int));

int main () { int m,n;

m = myoperator(7, 5, plus);

cout<<"m= "<

n = myoperator(20, m, minus);

cout<<" n= "<

return 0;

} int plus(int a, int b){ return (a+b);

} int minus (int a, int b){ return (a-b);

} int myoperator (int x, int y, int (*f)(int,int)) { int g;

g = (*f)(x,y);

return (g);

} Массивы как параметры При передаче массива в качестве параметра нужно:

– в заголовке функции после имени массива указать пустые квадратные скобки, например, int sum_arr(int arr[],int size_arr) – а в вызове функции указать имя массива уже без квадратных скобок:

sum=sum_arr(mass,N);

Пример. Использование массива как параметра функции.

// Массив как параметр функции // #include "stdafx.h" #include using namespace std;

const int N=8;

int sum_arr(int arr[],int);//прототип int _tmain(int argc, _TCHAR* argv[]) { int mass[N]={11,22,17,26,29,22,27,34};

int sum=sum_arr(mass,N);

cout<<"\nSumma="<

return 0;

} int sum_arr(int arr[],int size_arr) { int s=0;

for (int i=0;i< size_arr;i++) s+=arr[i];

return s;

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

Пример. Ещ одна версия передачи массива как параметра – формальный параметр функции объявлен как указатель.

// Массив как параметр функции // #include "stdafx.h" #include using namespace std;

const int N =8;

int sum_arr(int*,int );//прототип int _tmain(int argc, _TCHAR* argv[]) { int mass[N]={11,22,17,26,29,22,27,34};

int sum=sum_arr(mass,N);

cout<<"\nSumma="<

return 0;

} int sum_arr(int* arr,int n) { for(int i=0;i

arr[i]=-arr[i];// поменяли знак } return s;

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

Чтобы не допустить таких изменений, можно добавить в объявление массива-параметра модификатор const и тогда компилятор будет выдавать сообщение об ошибке при попытке изменить значения массива.

Пример. Использование массива как параметра функции – с помощью модификатора const запрещено изменение значений массива в функции.

#include "stdafx.h" #include using namespace std;

const int N=8;

int sum_arr(const int [],int);//прототип int _tmain(int argc, _TCHAR* argv[]) { int mass[N]={11,22,17,26,29,22,27,34};

int sum=sum_arr(mass,N);

cout<<"\nSumma="<

return 0;

} int sum_arr(const int arr[],int n) { int s=0;

for(int i=0;i

arr[i]=-arr[i];// теперь это ошибка } } Пример. Вычисление границы безразмерного символьного массива оформлено в виде функции size_char().

Pages:     | 1 |   ...   | 5 | 6 || 8 | 9 |   ...   | 11 |










© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.