Главная страница
Навигация по странице:

  • 4.5 Как создать библиотеку

  • 4.6 Функции

  • 4.6.1 Описания функций

  • 4.6.2 Определения функций

  • 4.6.3 Передача параметров

  • 4.6.4 Возвращаемое значение

  • 4.6.5 Параметр-массив

  • Бьерн Страуструп. Язык программирования С Второе дополненное издание


    Скачать 2.87 Mb.
    НазваниеБьерн Страуструп. Язык программирования С Второе дополненное издание
    Дата30.01.2020
    Размер2.87 Mb.
    Формат файлаpdf
    Имя файлаStraustrup-Yazyk_programmirovaniya_c.pdf
    ТипДокументы
    #106559
    страница10 из 35
    1   ...   6   7   8   9   10   11   12   13   ...   35
    4.4 Связывание с программами на других языках
    Программы на С++ часто содержат части, написанные на других языках, и наоборот, часто фрагмент на
    С++ используется в программах, написанных на других языках. Собрать в одну программу фрагменты, написанные на разных языках, или, написанные на одном языке, но в системах программирования с разными соглашениями о связывании, достаточно трудно. Например, разные языки или разные реализации одного языка могут различаться использованием регистров при передаче параметров, порядком размещения параметров в стеке, упаковкой таких встроенных типов, как целые или строки, форматом имен функций, которые транслятор передает редактору связей, объемом контроля типов, который требуется от редактора связей. Чтобы упростить задачу, можно в описании внешних указать условие связывания. Например, следующее описание объявляет strcpy внешней функцией и указывает, что она должна связываться согласно порядку связывания в С: extern "C" char* strcpy(char*, const char*);
    Результат этого описания отличается от результата обычного описания extern char* strcpy(char*, const char*); только порядком связывания для вызывающих strcpy() функций. Сама семантика вызова и, в частности, контроль фактических параметров будут одинаковы в обоих случаях. Описание extern "C" имеет смысл использовать еще и потому, что языки С и С++, как и их реализации, близки друг другу. Отметим, что в описании extern "C" упоминание С относится к порядку связывания, а не к языку, и часто такое описание используют для связи с Фортраном или ассемблером. Эти языки в определенной степени подчиняются порядку связывания для С.
    Утомительно добавлять "C" ко многим описаниям внешних, и есть возможность указать такую спецификацию сразу для группы описаний. Например: extern "C" { char* strcpy(char*, const char); int strcmp(const char*, const char*) int strlen(const char*)

    Бьерн Страуструп.
    Язык программирования С++
    105
    //
    }
    В такую конструкцию можно включить весь заголовочный файл С, чтобы указать, что он подчиняется связыванию для С++, например: extern "C" {
    #include

    }
    Обычно с помощью такого приема из стандартного заголовочного файла для С получают такой файл для С++. Возможно иное решение с помощью условной трансляции:
    #ifdef __cplusplus extern "C" {
    #endif char* strcpy(char*, const char*); int strcmp(const char*, const char*); int strlen(const char*);
    // ...
    #ifdef __cplusplus
    }
    #endif
    Предопределенное макроопределение __cplusplus нужно, чтобы обойти конструкцию extern "C" { ...}, если заголовочный файл используется для С.
    Поскольку конструкция extern "C" { ... } влияет только на порядок связывания, в ней может содержаться любое описание, например: extern "C" {
    // произвольные описания
    // например: static int st; int glob;
    }
    Никак не меняется класс памяти и область видимости описываемых объектов, поэтому по-прежнему st подчиняется внутреннему связыванию, а glob остается глобальной переменной.
    Укажем еще раз, что описание extern "C" влияет только на порядок связывания и не влияет на порядок вызова функции. В частности, функция, описанная как extern "C", все равно подчиняется правилам контроля типов и преобразования фактических параметров, которые в C++ строже, чем в С. Например: extern "C" int f(); int g()
    { return f(1); // ошибка: параметров быть не должно
    }
    4.5 Как создать библиотеку
    Распространены такие обороты (и в этой книге тоже): "поместить в библиотеку", "поискать в такой-то библиотеке". Что они означают для программ на С++? К сожалению, ответ зависит от используемой системы. В этом разделе говорится о том, как создать и использовать библиотеку для десятой версии системы ЮНИКС. Другие системы должны предоставлять похожие возможности. Библиотека состоит из файлов .o, которые получаются в результате трансляции файлов .c. Обычно существует один или несколько файлов .h, в которых содержатся необходимые для вызова файлов .o описания. Рассмотрим в качестве примера, как для четко не оговоренного множества пользователей можно достаточно удобно определить некоторое множество стандартных математических функций. Заголовочный файл может иметь такой вид: extern "C" {
    // стандартные математические функции

    Бьерн Страуструп.
    Язык программирования С++
    106
    // как правило написаны на С double sqrt(double); // подмножество double sin(double); double cos(double); double exp(double); double log(double);
    //
    }
    Определения этих функций будут находиться в файлах sqrt.c, sin.c, cos.c, exp.c и log.c, соответственно.
    Библиотеку с именем math.a можно создать с помощью таких команд:
    $ CC -c sqrt.c sin.c cos.c exp.c log.c
    $ ar cr math.a sqrt.o sin.o cos.o exp.o log.o
    $ ranlib math.a
    Здесь символ $ является приглашением системы.
    Вначале транслируются исходные тексты, и получаются модули с теми же именами. Команда ar
    (архиватор) создает архив под именем math.a. Наконец, для быстрого доступа к функциям архив индексируется. Если в вашей системе нет команды ranlib (возможно она и не нужна), то, по крайней мере, можно найти в справочном руководстве ссылку на имя ar. Чтобы использовать библиотеку в своей программе, надо задать режим трансляции следующим образом:
    $ CC myprog.c math.a
    Встает вопрос: что дает нам библиотека math.a? Ведь можно было бы непосредственно использовать файлы .o, например так:
    $ CC myprog.c sqrt.o sin.o cos.o exp.o log.o
    Дело в том, что во многих случаях трудно правильно указать, какие файлы .o действительно нужны. В приведенной выше команде использовались все из них. Если же в myprog вызываются только sqrt() и cos(), тогда, видимо, достаточно задать такую команду:
    $ CC myprog.c sqrt.o cos.o
    Но это будет неверно, т.к. функция cos() вызывает sin().
    Редактор связей, который вызывается командой CC для обработки файлов .a (в нашем случае для файла math.a), умеет из множества файлов, образующих библиотеку, извлекать только нужные файлы
    .o. Иными словами, связывание с библиотекой позволяет включать в программы много определений одного имени (в том числе определения функций и переменных, используемых только внутренними функциями, о которых пользователь никогда не узнает). В то же время в результирующую программу войдет только минимально необходимое число определений.
    4.6 Функции
    Самый распространенный способ задания в С++ каких-то действий - это вызов функции, которая выполняет такие действия. Определение функции есть описание того, как их выполнить. Неописанные функции вызывать нельзя.
    4.6.1 Описания функций
    Описание функции содержит ее имя, тип возвращаемого значения (если оно есть) и число и типы параметров, которые должны задаваться при вызове функции. Например: extern double sqrt(double); extern elem* next_elem(); extern char* strcpy(char* to, const char* from); extern void exit(int);
    Семантика передачи параметров тождественна семантике инициализации: проверяются типы

    Бьерн Страуструп.
    Язык программирования С++
    107 фактических параметров и, если нужно, происходят неявные преобразования типов. Так, если учесть приведенные описания, то в следующем определении: double sr2 = sqrt(2); содержится правильный вызов функции sqrt() со значением с плавающей точкой 2.0. Контроль и преобразование типа фактического параметра имеет в С++ огромное значение.
    В описании функции можно указывать имена параметров. Это облегчает чтение программы, но транслятор эти имена просто игнорирует.
    4.6.2 Определения функций
    Каждая вызываемая в программе функция должна быть где-то в ней определена, причем только один раз. Определение функции - это ее описание, в котором содержится тело функции. Например: extern void swap(int*, int*);
    // описание void swap(int* p, int* q) // определение
    { int t = *p;
    *p = *q;
    *q = *t;
    }
    Не так редки случаи, когда в определении функции не используются некоторые параметры: void search(table* t, const char* key, const char*)
    {
    // третий параметр не используется
    //
    }
    Как видно из этого примера, параметр не используется, если не задано его имя. Подобные функции появляются при упрощении программы или если рассчитывают на ее дальнейшее расширение. В обоих случаях резервирование места в определении функции для неиспользуемого параметра гарантирует, что другие функции, содержащие вызов данной, не придется менять.
    Уже говорилось, что функцию можно определить как подстановку (inline). Например: inline fac(int i) { return i<2 ? 1 : n*fac(n-1); }
    Спецификация inline служит подсказкой транслятору, что вызов функции fac можно реализовать подстановкой ее тела, а не с помощью обычного механизма вызова функций ($$R.7.1.2). Хороший оптимизирующий транслятор вместо генерации вызова fac(6) может просто использовать константу 720.
    Из-за наличия взаиморекурсивных вызовов функций-подстановок, а также функций-подстановок, рекурсивность которых зависит от входных данных, нельзя утверждать, что каждый вызов функции- подстановки действительно реализуется подстановкой ее тела. Степень оптимизации, проводимой транслятором, нельзя формализовать, поэтому одни трансляторы создадут команды 6*5*4*3*2*1, другие - 6*fac(5), а некоторые ограничатся неоптимизированным вызовом fac(6).
    Чтобы реализация вызова подстановкой стала возможна даже для не слишком развитых систем программирования, нужно, чтобы не только определение, но и описание функции-подстановки находилось в текущей области видимости. В остальном спецификация inline не влияет на семантику вызова.
    4.6.3 Передача параметров
    При вызове функции выделяется память для ее формальных параметров, и каждый формальный параметр инициализируется значением соответствующего фактического параметра. Семантика передачи параметров тождественна семантике инициализации. В частности, сверяются типы формального и соответствующего ему фактического параметра, и выполняются все стандартные и пользовательские преобразования типа. Существуют специальные правила передачи массивов
    ($$4.6.5). Есть возможность передать параметр, минуя контроль типа ($$4.6.8), и возможность задать

    Бьерн Страуструп.
    Язык программирования С++
    108 стандартное значение параметра ($$4.6.7). Рассмотрим функцию: void f(int val, int& ref)
    { val++; ref++;
    }
    При вызове f() в выражении val++ увеличивается локальная копия первого фактического параметра, тогда как в ref++ - сам второй фактический параметр увеличивается сам. Поэтому в функции void g()
    { int i = 1; int j = 1; f(i,j);
    } увеличится значение j, но не i. Первый параметр i передается по значению, а второй параметр j передается по ссылке. В $$2.3.10 мы говорили, что функции, которые изменяют свой передаваемый по ссылке параметр, труднее понять, и что поэтому лучше их избегать (см. также $$10.2.2). Но большие объекты, очевидно, гораздо эффективнее передавать по ссылке, чем по значению. Правда можно описать параметр со спецификацией const, чтобы гарантировать, что передача по ссылке используется только для эффективности, и вызываемая функция не может изменить значение объекта: void f(const large& arg)
    {
    // значение "arg" нельзя изменить без явных
    // операций преобразования типа
    }
    Если в описании параметра ссылки const не указано, то это рассматривается как намерение изменять передаваемый объект: void g(large& arg); // считается, что в g() arg будет меняться
    Отсюда мораль: используйте const всюду, где возможно.
    Точно так же, описание параметра, являющегося указателем, со спецификацией const говорит о том, что указуемый объект не будет изменяться в вызываемой функции. Например: extern int strlen(const char*); // из extern char* strcpy(char* to, const char* from); extern int strcmp(const char*, const char*);
    Значение такого приема растет вместе с ростом программы.
    Отметим, что семантика передачи параметров отличается от семантики присваивания. Это различие существенно для параметров, являющихся const или ссылкой, а также для параметров с типом, определенным пользователем ($1.4.2).
    Литерал, константу и параметр, требующий преобразования, можно передавать как параметр типа const&, но без спецификации const передавать нельзя. Допуская преобразования для параметра типа const T&, мы гарантируем, что он может принимать значения из того же множества, что и параметр типа
    T, значение которого передается при необходимости с помощью временной переменной. float fsqrt(const float&);
    // функция sqrt в стиле Фортрана void g(double d)
    { float r; r = fsqrt(2.0f);
    // передача ссылки на временную
    // переменную, содержащую 2.0f r = fsqrt(r);
    // передача ссылки на r r = fsqrt(d);
    // передача ссылки на временную
    // переменную, содержащую float(d)

    Бьерн Страуструп.
    Язык программирования С++
    109
    }
    Запрет на преобразования типа для параметров-ссылок без спецификации const введен для того, чтобы избежать нелепых ошибок, связанных с использованием при передаче параметров временных переменных: void update(float& i); void g(double d)
    { float r; update(2.0f); // ошибка: параметр-константа update(r); // нормально: передается ссылка на r update(d); // ошибка: здесь нужно преобразовывать тип
    }
    4.6.4 Возвращаемое значение
    Если функция не описана как void, она должна возвращать значение. Например: int f() { } // ошибка void g() { } // нормально
    Возвращаемое значение указывается в операторе return в теле функции. Например: int fac(int n) { return (n>1) ? n*fac(n-1) : 1; }
    В теле функции может быть несколько операторов return: int fac(int n)
    { if (n > 1) return n*fac(n-1); else return
    1;
    }
    Подобно передаче параметров, операция возвращения значения функции эквивалентна инициализации. Считается, что оператор return инициализирует переменную, имеющую тип возвращаемого значения. Тип выражения в операторе return сверяется с типом функции, и производятся все стандартные и пользовательские преобразования типа. Например: double f()
    {
    // return 1; // неявно преобразуется в double(1)
    }
    При каждом вызове функции создается новая копия ее формальных параметров и автоматических переменных. Занятая ими память после выхода из функции будет снова использоваться, поэтому неразумно возвращать указатель на локальную переменную. Содержимое памяти, на которую настроен такой указатель, может измениться непредсказуемым образом: int* f()
    { int local = 1;
    // return &local; // ошибка
    }
    Эта ошибка не столь типична, как сходная ошибка, когда тип функции - ссылка: int& f()
    { int local = 1;
    //

    Бьерн Страуструп.
    Язык программирования С++
    110 return local; // ошибка
    }
    К счастью, транслятор предупреждает о том, что возвращается ссылка на локальную переменную. Вот другой пример: int& f() { return 1; } // ошибка
    4.6.5 Параметр-массив
    Если в качестве параметра функции указан массив, то передается указатель на его первый элемент.
    Например: int strlen(const char*); void f()
    { char v[] = "
    массив"; strlen(v); strlen("
    Николай");
    }
    Это означает, что фактический параметр типа T[] преобразуется к типу T*, и затем передается. Поэтому присваивание элементу формального параметра-массива изменяет этот элемент. Иными словами, массивы отличаются от других типов тем, что они не передаются и не могут передаваться по значению.
    В вызываемой функции размер передаваемого массива неизвестен. Это неприятно, но есть несколько способов обойти данную трудность. Прежде всего, все строки оканчиваются нулевым символом, и значит их размер легко вычислить. Можно передавать еще один параметр, задающий размер массива.
    Другой способ: определить структуру, содержащую указатель на массив и размер массива, и передавать ее как параметр (см. также $$1.2.5). Например: void compute1(int* vec_ptr, int vec_size); // 1- ый способ struct vec {
    // 2- ой способ int* ptr; int size;
    }; void compute2(vec v);
    Сложнее с многомерными массивами, но часто вместо них можно использовать массив указателей, сведя эти случаи к одномерным массивам. Например: char* day[] = {
    "mon", "tue", "wed", "thu", "fri", "sat", "sun"
    };
    Теперь рассмотрим функцию, работающую с двумерным массивом - матрицей. Если размеры обоих индексов известны на этапе трансляции, то проблем нет: void print_m34(int m[3][4])
    { for (int i = 0; i<3; i++) { for (int j = 0; j<4; J++) cout << ' ' << m[i][j]; cout
    <<
    '\n';
    }
    }
    Конечно, матрица по-прежнему передается как указатель, а размерностиприведены просто для полноты описания.
    Первая размерность для вычисления адреса элемента неважна($$R.8.2.4), поэтому ее можно передавать как параметр: void print_mi4(int m[][4], int dim1)

    Бьерн Страуструп.
    Язык программирования С++
    111
    { for ( int i = 0; i }
    }
    Самый сложный случай - когда надо передавать обе размерности. Здесь "очевидное" решение просто непригодно: void print_mij(int m[][], int dim1, int dim2) // ошибка
    { for ( int i = 0; i<<
    '\n';
    }
    }
    Во-первых, описание параметра m[][] недопустимо, поскольку для вычисления адреса элемента многомерного массива нужно знать вторую размерность. Во-вторых, выражение m[i][j] вычисляется как
    *(*(m+i)+j), а это, по всей видимости, не то, что имел в виду программист. Приведем правильное решение: void print_mij(int** m, int dim1, int dim2)
    { for (int i = 0; i< dim1; i++) { for (int j = 0; j<<
    '\n';
    }
    }
    Выражение, используемое для выбора элемента матрицы, эквивалентно тому, которое создает для этой же цели транслятор, когда известна последняя размерность. Можно ввести дополнительную переменную, чтобы это выражение стало понятнее: int* v = (int*)m;
    // ... v[i*dim2+j]
    Лучше такие достаточно запутанные места в программе упрятывать. Можно определить тип многомерного массива с соответствующей операцией индексирования. Тогда пользователь может и не знать, как размещаются данные в массиве (см. упражнение 18 в $$7.13).
    1   ...   6   7   8   9   10   11   12   13   ...   35


    написать администратору сайта