Опубликован: 10.10.2006 | Доступ: свободный | Студентов: 6020 / 456 | Оценка: 4.26 / 3.88 | Длительность: 31:30:00
Лекция 2:

Описания и константы

2.3.7 Указатели и массивы

Указатели и массивы в языке Си++ тесно связаны. Имя массива можно использовать как указатель на его первый элемент, поэтому пример с массивом alpha можно записать так:

int main()
 {
  char alpha[] = "abcdefghijklmnopqrstuvwxyz";
  char* p = alpha;
   char ch;

   while (ch = *p++)
        cout << ch << " = " << int (ch)
             << " = 0" << oct(ch) << '\n';
}

Можно также задать описание p следующим образом:

char* p = &alpha[0];

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

void f()
{
  extern "C" int strlen(const char*);  // из <string.h>
  char v[] = "Annemarie";
  char* p = v;
  strlen(p);
  strlen(v);
}

Но в том и загвоздка, что обойти это нельзя: не существует способа так описать функцию, чтобы при ее вызове массив v копировался. Результат применения к указателям арифметических операций +, -, ++ или -- зависит от типа указуемых объектов. Если такая операция применяется к указателю p типа T*, то считается, что p указывает на массив объектов типа T. Тогда p+1 обозначает следующий элемент этого массива, а p-1 - предыдущий элемент. Отсюда следует, что значение (адрес) p+1 будет на sizeof(T) байтов больше, чем значение p. Поэтому в следующей программе

main()
    {
 char cv[10];
 int iv[10];

 char* pc = cv;
 int* pi = iv;

 cout << "char* " << long(pc+1)-long(pc) << '\n';
 cout << "int*  " << long(pi+1)-long(pi) << '\n';
    }

с учетом того, что на машине автора (Macintosh) символ занимает один байт, а целое - четыре байта, получим:

char* 1
int*  4

Перед вычитанием указатели были явной операцией преобразованы к типу long. Он использовался для преобразования вместо "очевидного" типа int, поскольку в некоторых реализациях языка С++ указатель может не поместиться в тип int (т.е. sizeof(int *)<(sizeof(char*)) ). Вычитание указателей определено только в том случае, когда они оба указывают на один и тот же массив (хотя в языке нет возможностей гарантировать этот факт). Результат вычитания одного указателя из другого равен числу (целое) элементов массива, находящихся между этими указателями. Можно складывать с указателем или вычитать из него значение целого типа; в обоих случаях результатом будет указатель. Если получится значение, не являющееся указателем на элемент того же массива, на который был настроен исходный указатель (или указателем на следующий за массивом элемент), то результат использования такого значения неопределен. Приведем пример:

void f()
{
  int v1[10];
  int v2[10];

  int i = &v1[5]-&v1[3];    // 2
  i = &v1[5]-&v2[3];    // неопределенный результат

   int* p = v2+2;            // p == &v2[2]
        p = v2-2;            // *p неопределено
}

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

2.3.8 Структуры

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

struct address {
     char* name;         // имя "Jim Dandy"
     long  number;       // номер дома 61
     char* street;       // улица "South Street"
     char* town;         // город "New Providence"
     char* state[2];     // штат 'N' 'J'
      int   zip;          // индекс 7974
 };

Здесь определяется новый тип, называемый address, который задает почтовый адрес. Определение не является достаточно общим, чтобы учесть все случаи адресов, но оно вполне пригодно для примера. Обратите внимание на точку с запятой в конце определения: это один из немногих в С++ случаев, когда после фигурной скобки требуется точка с запятой, поэтому про нее часто забывают. Переменные типа address можно описывать точно так же, как и любые другие переменные, а с помощью операции . (точка) можно обращаться к отдельным членам структуры. Например:

address jd;
jd.name = "Jim Dandy";
jd.number = 61;

Инициализировать переменные типа struct можно так же, как массивы. Например:

address jd = {
   "Jim Dandy",
    61, "South Street",
    "New Providence", {'N','J'}, 7974
};

Но лучше для этих целей использовать конструктор. Отметим, что jd.state нельзя инициализировать строкой "NJ". Ведь строки оканчиваются нулевым символом '\0', значит в строке "NJ" три символа, а это на один больше, чем помещается в jd.state. К структурным объектам часто обращаются c помощью указателей, используя операцию ->. Например:

void print_addr(address* p)
{
 cout << p->name << '\n'
       << p->number << ' ' << p->street << '\n'
       << p->town << '\n'
       << p->state[0] << p->state[1]
      << ' ' << p->zip << '\n';
}

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

address current;

address set_current(address next)
{
  address prev = current;
  current = next;
  return prev;
}

Другие допустимые операции, например, такие, как сравнение (== и !=), неопределены. Однако пользователь может сам определить эти операции (см. "лекцию 7" ).

Размер объекта структурного типа не обязательно равен сумме размеров всех его членов. Это происходит по той причине, что на многих машинах требуется размещать объекты определенных типов, только выравнивая их по некоторой зависящей от системы адресации границе (или просто потому, что работа при таком выравнивании будет более эффективной ). Типичный пример - это выравнивание целого по условной границе. В результате выравнивания могут появиться "дырки" в структуре. Так, на уже упоминавшейся машине автора sizeof(address) равно 24, а не 22, как можно было ожидать. Следует также упомянуть, что тип можно использовать сразу после его появления в описании, еще до того, как будет завершено все описание. Например:

struct link{
       link* previous;
       link* successor;
 };

Однако новые объекты типа структуры нельзя описать до тех пор, пока не появится ее полное описание. Поэтому описание

struct no_good {
   no_good member;
 };

является ошибочным (транслятор не в состоянии установить размер no_good ). Чтобы позволить двум (или более) структурным типам ссылаться друг на друга, можно просто описать имя одного из них как имя некоторого структурного типа. Например:

struct list;        // будет определено позднее

  struct link {
      link* pre;
      link* suc;
      list* member_of;
  };

 struct list {
       link* head;
 };

Если бы не было первого описания list, описание члена link привело бы к синтаксической ошибке. Можно также использовать имя структурного типа еще до того, как тип будет определен, если только это использование не предполагает знания размера структуры. Например:

class S;        // 'S' - имя некоторого типа

extern S a;

S f();

void g(S);

Но приведенные описания можно использовать лишь после того, как тип S будет определен:

void h()
{
  S a;        // ошибка: S - неописано
   f();        // ошибка: S - неописано
   g(a);       // ошибка: S - неописано
}
Дарья Федотова
Дарья Федотова
Сергей Березовский
Сергей Березовский

В рамках проф. переподготовки по программе "Программирование"

Есть курсы, которые я уже прошел. Но войдя в курс я вижу, что они не зачтены (Язык Ассемблера и архитектура ЭВМ, Программирование на С++ для профессионалов). Это как?

Роман Островский
Роман Островский
Украина
Оксана Пагина
Оксана Пагина
Россия, Москва