[ новости /+++ | форум | теги | ]

Каталог документации / Раздел "Программирование, языки" / Оглавление документа

7.70.

Разработайте архитектуру и систему команд учебной машины и напишите интерпретатор учебного ассемблера, отрабатывающего по крайней мере такие команды:

    mov пересылка (:=)    add сложение
    sub вычитание         cmp сравнение и выработка признака
    jmp переход           jeq переход, если ==
    jlt переход, если <   jle переход, если <=
    neg изменение знака   not инвертирование признака

7.71.

Напишите программу, преобразующую определения функций Си в "старом" стиле в "новый" стиль стандарта ANSI ("прототипы" функций).

            f(x, y, s, v)
                  int x;
                  char *s;
                  struct elem *v;
            { ... }

преобразуется в

            int f(int x, int y, char *s, struct elem *v)
            { ... }

(обратите внимание, что переменная y и сама функция f описаны по умолчанию как int).

Еще пример:

       char *ff()    { ... }
            заменяется на
       char *ff(void){ ... }

В данной задаче вам возможно придется использовать программу lex.

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

    q(x, s) char *s; { ... }  // не прототип, допустимо.
                              // x - int по умолчанию.
    q(x,     char *s);        // недопустимо.
    q(int x, char *s);        // верно.

Собственно под "прототипом" понимают предварительное описание функции в новом стиле где вместо тела {...} сразу после заголовка стоит точка с запятой.

    long f(long x, long y);                /* прототип */
    long f(long x, long y){ return x+y; }  /* реализация */

В прототипе имена аргументов можно опускать:

    long f(long, long);                /* прототип */
    char *strchr(char *, char);

Это предварительное описание помещают где-нибудь в начале программы, до первого вызова функции. В современном Си прототипы заменяют описания вида

    extern long f();

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

    double f( double );

и вызывается как

    double x = f( 12 );

то компилятор автоматически превратит это в

    double x = f( (double) 12 );

(поскольку существует приведение типа от int к double); если же написано

    f( "привет" );

то компилятор сообщит об ошибке (так как нет преобразования типа (char *) в double). Прототип принуждает компилятор проверять:

1. соответствие ТИПОВ фактических параметров (при вызове) типам формальных параметров (в прототипе);
2. соответствие КОЛИЧЕСТВА фактических и формальных параметров;
3. тип возвращаемого функцией значения.

Прототипы обычно помещают в include-файлы. Так в ANSI стандарте Си предусмотрен файл, подключаемый

            #include <stdlib.h>

в котором определены прототипы функций из стандартной библиотеки языка Си. Черезвычайно полезно писать эту директиву include, чтобы компилятор проверял, верно ли вы вызываете стандартные функции.

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

            extern int x;
            extern char *func();

Если вы не используете переменную или функцию с таким именем, то эти строки не имеют никакого эффекта (как бы вообще отсутствуют).

7.72.

Обратная задача: напишите преобразователь из нового стиля в старый.

            int f( int x, char *y ){ ... }

переводить в

            int f( x, y ) int x; char *y; { ... }

7.73.

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

    -------    файл a.c
    -------    void g(void);
    void h(void);
    int x = 0, y = 13;
    void f(int arg){
            printf("f(%d)\n", arg);
            x = arg;
            x++;
    }
    int main(int ac, char *av[]){
            h();
            f(1);
            g();
            printf("x=%d y=%d\n", x, y);
            return 0;
    }
    -------    файл b.c
    -------    extern int x, y;
    int f(int);
    void g(){
            y = f(5);
    }
    -------    файл c.c
    -------    void f();
    void h(){
            f();
    }
Выдача программы:
    abs@wizard$ cc a.c b.c c.c -o aaa
    a.c:
    b.c:
    c.c:
    abs@wizard$ aaa
    f(-277792360)
    f(1)
    f(5)
    x=6 y=5
    abs@wizard$

Обратите внимание, что во всех трех файлах f() имеет разные прототипы! Поэтому программа печатает нечто, что довольно-таки бессмысленно!

Решение таково: стараться вынести прототипы в include-файл, чтобы все файлы программы включали одни и те же прототипы. Стараться, чтобы этот include-файл включался также в файл с самим определением функции. В таком случае изменение только заголовка функции или только прототипа вызовет ругань компилятора о несоответствии. Вот как должен выглядеть наш проект:

    ------------    файл header.h
    ------------    extern int x, y;
    void f(int arg);
    int main(int ac, char *av[]);
    void g(void);
    void h(void);
    -------    файл a.c
    -------    #include "header.h"
    int x = 0, y = 13;
    void f(int arg){
            printf("f(%d)\n", arg);
            x = arg;
            x++;
    }
    int main(int ac, char *av[]){
            h();
            f(1);
            g();
            printf("x=%d y=%d\n", x, y);
            return 0;
    }
    -------    файл b.c
    -------    #include "header.h"
    void g(){
            y = f(5);
    }
    -------    файл c.c
    -------    #include "header.h"
    void h(){
            f();
    }

Попытка компиляции:

    abs@wizard$ cc a.c b.c c.c -o aaa
    a.c:
    b.c:
    "b.c", line 4: operand cannot have void type: op "="
    "b.c", line 4: assignment type mismatch:
            int "=" void
    cc: acomp failed for b.c
    c.c:
    "c.c", line 4: prototype mismatch: 0 args passed, 1 expected
    cc: acomp failed for c.c

© Copyright А. Богатырев, 1992-95
Си в UNIX

Партнёры:

Хостинг: