Лекция 2. Основные определения языка высокого уровня (стр. 9 )

unsigned int * a; /* переменная а представляет собой указатель

на тип unsigned int (целые числа без знака) */

double * x; /* переменная х указывает на тип данных с

плавающей точкой удвоенной точности */

char * fuffer ; /* объявляется указатель с именем fuffer

который указывает на переменную типа char */

int * countPtr, count, c; /*Объявлен указатель countPtr,

в котором может храниться адрес переменной типа int.

count - это переменная типа int, а не указатель

(перед count нет звездочки). */

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

double nomer;

void *addres;

addres = & nomer;

addres ++; //не получится, т. к. addres - указатель на void

(*(double*)addres) ++; //так можно - увеличивается содержимое

double *ad;

((double*)addres) ++; //так нельзя - изменять указатель на void

ad = (double*)addres+1; //увеличивает указатель на 8 -

//изменять указатель на не void можно

Переменная addres объявлена как указатель на объект любого типа. Поэтому ей можно присвоить адрес любого объекта (& - операция получения адреса). Однако, как было отмечено выше, ни одна арифмитическая операция не может быть выполнена над указателем, пока не будет явно определен тип данных, на которые он указывает. Это можно сделать, используя операцию приведения типа (double *) для преобразования addres к указателю на тип double.

const int * dr;

/* Переменная dr объявлена как указатель на константное выражение,

т. е. значение указателя может изменяться в процессе выполнения

программы, а величина, на которую он указывает, нет. */

char * const w = &obj.

/* Переменная w объявлена как константный указатель на данные типа char. Это означает, что на протяжение всей программы w будет указывать на одну и ту же область памяти (поэтому необходимо при описании присвоить значение).

Содержание же этой области может быть изменено. */

w++;//не получится, т. к. указатель const

*w++;//нормально - увеличить не указатель, а содержимое

*w='A';//нормально - изменить не указатель, а содержимое

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

int ii;

int * i = ⅈ //указатель на ii

int * j = 0; //пустой указатель

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

if (i) //проверка на то, что указатель инициализирован

Если указатель не ссылается на объект его нельзя разыменовывать.

Операции над указателями

1) Получение указателя &

int * countPtr; /*Объявлен указатель countPtr */

int count, c;

cout << &count;

2) Присваивание указателю адреса существующего объекта =

countPtr = &count;

3) Разадресация указателя *

Чтобы вывести count на экран достаточно написать

cout << count;

или

cout << *countPtr;

или

с = *countPtr;

cout << c;

использование * указанным способом называется разадресацией указателя. Это операция обратная получению указателя.

4) Выделение участка динамической памяти и присваивание ее адреса указателю

long * l = new long;

new выделяет достаточное для размещения переменной типа long участка динамической памяти и записывает адрес начала этого участка в переменную l.

long * l = new long(10);

Такая запись помимо выше описанных действий инициализирует выделенную память числом 10 (*l=10).

long * l2 = new long[10];

Такая запись выделяет память под 10 величин типа long.

*l2 = 1; //первая

*(l2+1) =2; //вторая

*(l2+9) =100; //последняя

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

delete l;

delete l2[];

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

4) Арифметические операции над указателями

----------------------------------------

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

Арифметические операции над указателями:

Инкремент — смещенеие к следующему элементу,

декремент — смещенеие к предыдующему элементу,

сложение с константой n — сдвиг на n элементов вправо,

вычитание константы n — сдвиг на n элементов влево,

вычитание указателя — количество элементов между указателями.

Например, инкремент указателя ++ увеличивает указатель не на 1, а перемещает указатель к следующему элементу, то есть указатель увеличивается на величину sizeof(тип).

int *d =1000;

d++; //d=1004;

double *dd =1000;

dd++; dd=1008;

Это имеет смысл при работе с последовательно расположенными данными одного типа, например, массивами.

Указатель на функцию

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

Функция int fun(double a, int *b)

будет иметь тип

int (*tipfun) (double, int);

Определим этот тип в программе:

typedef int (*tipfun) (double, int);

tipfun f;

f = fun; //f - переменная типа указатель функции

Рассмотрим пример использования указателя на функцию в качестве параметра функции, вычисляющей производную от функции cos(x).

Пример.

/* функция от которой вычисляется производная */

double fun (double z)

{

return (exp(z)+5*z*z);

}

/* функция вычисляющая производную */

double proiz(double x, double dx, double (*f)(double z) )

{

double xk, xk1,pr;

xk=f(x);

xk1=f(x+dx);

pr=(xk1-xk)/dx;

return pr;

}

int main()

{

double x; /* точка вычисления производной */

double dx; /* приращение */

double z; /* значение производной */

cin >> x >> dx;

z = proiz (x, dx, fun); /* вызов функции */

cout << z;

return 0;

}

Для вычисления производной от какой-либо другой функции можно изменить тело функции fun или использовать при вызове функции proiz имя другой функции. В частности, для вычисления производной от функции cos(x) можно вызвать функцию proiz в форме

z=proiz(x, dx, cos);

а для вычисления производной от функции sin(x) в форме

z=proiz(x, dx, sin);

Это возможно поскольку функции cos и sin имеют также тип

double (*f)(double z).

Взаимосвязь между массивом и указателем

Идентификатор массива является константным указателем на его нулевой элемент.

Если имеется массив m[N], то m - константный указатель на нулевой элемент.

m ==== &m[0]

m+1 ==== &m[1]

m+i ==== &m[i]

То есть к i-ому элементу массива можно обратиться, используя выражение

*(m+i).

*(m+i) ==== m[i]

*(m+1) ==== m[1]

Лекция 8. Строки

В C строка — последовательность символов, размещенных в одномерном массиве, завершающаяся нуль-символом '\0' с кодом ноль.

Описание строки осуществляется следующим образом:

char str1[10];

char str2[]='Hello'; //==== char str2[6]='Hello'; H e l l o \0

cout << str2[4]; //вывести букву 'o'

cout << str2[0]; //вывести букву 'H'

str2[0]='h';

В C++ есть две возможности для работы со строками: функции, унаследованные из библиотеки C (<string. h> или <cstring>) и библиотечный класс string, который будет рассматриваться в следующем семестре.

Библиотека C включает следующие функции:

копирования (strcpy, strncpy);

сравнения (strcmp, strncmp);

объединения строк (strcat, strncat);

поиска подстроки (strstr);

поиска вхождения символа (strchr, strrchr, strpbrk);

определения длины строки (strlen) и др.

В заголовочных файлах <stdlib. h> и <cstdlib> содержатся функции

преобразования строк в числа:

double atof (const char * p);

int atoi (const char * p);

long atol (const char * p);

Обратные преобразования осуществляются с помощью функции sprintf.

Пример. Программа заносит в строку s3 содержимое s1 и s2, если в строке s1 записано "Hello".

void main (void)

{

char s1[] = "....", s2[] = ".....";

char * s3; //s3 — указатель. Под строку память не выделена

//Можно так char s3[100]; //но не известна чему будет равна длина.

if (strcmp(s1, "Hello") == 0)

{

s3 = new char[strlen(s1) + strlen(s2) + 1];

strcpy(s3, s1);

strcat(s3, s2);

}

cout << s3;

}

Пример. Программа заполняет массив типа double из строки:

#include <stdio. h>

#include <string. h>

#include <stdlib. h>

int main()

{

char s[] = "2, 38.5, 70, 0, 9, 1";

char *p =s;

double m[10];

int i=0;

do {

m[i++] = atof(p);

if (i>9) break;

} while (p=strchr(p, ','), p++);

for (int k=0; k<i; k++) printf("%5.2f ", m[k]);

return 0;

}

Строка состоит из симолов типа char.

Для работы с символами (загол. файлы <ctype. h> и <cctype>) есть следующие функции:

isalnum isalpha iscntrl isdigit isgraph intbl islower

isprint ispunch isspace isupper isxdigit

Функции принимают значение int и возвращают значение true, если

аргумент является символом, входящим в соответствующую группу.

В стандартном заголовочном файле <ctype. h> определены несколько функций, полезных для обработки при вводе:

int isalpha(char) // 'a'..'z' 'A'..'Z'

int isupper(char) // 'A'..'Z'

int islower(char) // 'a'..'z'

int isdigit(char) // '0'..'9'

int isxdigit(char) // '0'..'9' 'a'..'f' 'A'..'F'

int isspace(char) // ' ' '\t' возвращает конец строки

// и перевод формата

int iscntrl(char) // управляющий символ в диапазоне

// (ASCII 0..31 и 127)

int ispunct(char) // знак пунктуации, отличен от приведенных выше