Показаны сообщения с ярлыком C language. Показать все сообщения
Показаны сообщения с ярлыком C language. Показать все сообщения

воскресенье, 31 октября 2021 г.

Создаем GTK список (виджет)

 Приведу без комментариев код. 

// gtktable.c
#include <stdio.h>
#include <gtk-3.0/gtk/gtk.h>

GtkWidget* main_window;
GtkWidget* box1;
GtkWidget* scroll_window;

GtkWidget* list_widget;
GtkTreeStore* store_list;
enum{COL1, COL2, COL3, NCOL};
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection* selection;
GtkTreeIter iter1;

gboolean
selection_func (GtkTreeSelection *selection,
                     GtkTreeModel     *model,
                     GtkTreePath      *path,
                     gboolean          path_currently_selected,
                     gpointer          userdata)
{
    g_print ("selection_func is called.\n");
    return TRUE;
}

void
create_gtk_table(){
    store_list = gtk_tree_store_new(NCOL, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING);
    list_widget = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store_list));
    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list_widget));
    gtk_tree_selection_set_select_function(selection, selection_func, NULL, NULL);

    gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(list_widget), TRUE);
    gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(list_widget),GTK_TREE_VIEW_GRID_LINES_BOTH);
    gtk_container_add(GTK_CONTAINER(scroll_window), list_widget);

    renderer = gtk_cell_renderer_text_new();
    g_object_set(G_OBJECT(renderer), "background", "grey", NULL);
    g_object_set(G_OBJECT(renderer), "foreground", "black", NULL);

    column = gtk_tree_view_column_new_with_attributes("Title1",renderer, "text", COL1, NULL);
    gtk_tree_view_column_set_clickable(column, TRUE);
    gtk_tree_view_append_column(GTK_TREE_VIEW(list_widget), column);

    column = gtk_tree_view_column_new_with_attributes("Title2",renderer, "text", COL2, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW(list_widget), column);

    column = gtk_tree_view_column_new_with_attributes("Title3",renderer, "text", COL3, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW(list_widget), column);

    g_object_unref(G_OBJECT(store_list));

    for(gint i = 0 ; i < 100; i++){
      gtk_tree_store_append(store_list, &iter1, NULL);
      gtk_tree_store_set(store_list, &iter1, COL1, i+1, COL2, "string ?", COL3, "the string!", -1);
    }
}

void
activate (GtkApplication *app,
          gpointer        user_data)
{
    main_window = gtk_application_window_new (app);
    gtk_window_set_title (GTK_WINDOW (main_window), "The Table in The Scrolling");
    gtk_window_set_default_size (GTK_WINDOW (main_window), 400, 500);
    gtk_container_set_border_width (GTK_CONTAINER (main_window), 20);

    box1 = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
    gtk_box_set_homogeneous (GTK_BOX(box1), FALSE);
    gtk_container_add (GTK_CONTAINER (main_window), box1);

    scroll_window = gtk_scrolled_window_new(NULL, NULL);
    gtk_widget_set_size_request(scroll_window, 350, 450);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
    gtk_box_pack_start(GTK_BOX (box1), scroll_window, FALSE, FALSE, 10);

    create_gtk_table();

    gtk_widget_show_all (main_window);
}

int main(int argc, char **argv) {
    GtkApplication *app;
    int status;
    app = gtk_application_new ("org.gtk.the_sin", G_APPLICATION_FLAGS_NONE);
    g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
    status = g_application_run (G_APPLICATION (app), argc, argv);
    g_object_unref (app);
    return status;
}

Код, который ответственнен за создание списка находится в функции  create_gtk_table. После выполнения эта программа выводит на дисплей вот такое:

Если для компиляции ипользовать CMake, то необходимо создать файл CMakeLists.txt следующего содержания:

cmake_minimum_required (VERSION 3.18)

project (gtktable)
find_package (PkgConfig REQUIRED)
pkg_check_modules (GTK3 REQUIRED gtk+-3.0)
include_directories (${GTK3_INCLUDE_DIRS})
link_directories (${GTK3_LIBRARY_DIRS})
add_executable(gtktable gtktable.c)
add_definitions (${GTK3_CFLAGS_OTHER})
target_link_libraries (gtktable ${GTK3_LIBRARIES})

Компилировалось и выполнялось на Debian Bullseye. Собственно, это все, что хотел сказать.

четверг, 14 октября 2021 г.

Простейшее испльзования систем CMake и Meson на примере gtk+ приложения

 Напишем простое gtk приложение, которое считает sin от вводимой величины. 

//   calc_sin.c
#include <gtk/gtk.h>
#include <math.h>

GtkWidget* main_window;
GtkWidget* box1;

GtkWidget* edit1;
GtkWidget* button1;
GtkWidget* label1;
GtkWidget* button_exit;

void
calc_sin(){
    double result = sin(atof(gtk_entry_get_text(GTK_ENTRY(edit1))));
    gchar *display = g_strdup_printf("%f", result);   
    gtk_label_set_text (GTK_LABEL(label1), display);
    g_free(display); 
}

void
activate (GtkApplication *app,
          gpointer        user_data)
{
      main_window = gtk_application_window_new (app);
      gtk_window_set_title (GTK_WINDOW (main_window), "The sin");
      gtk_window_set_default_size (GTK_WINDOW (main_window), 200, 400);
      gtk_container_set_border_width (GTK_CONTAINER (main_window), 20);

      box1 = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
      gtk_box_set_homogeneous (GTK_BOX(box1), FALSE);
      gtk_container_add (GTK_CONTAINER (main_window), box1);

      edit1=gtk_entry_new();
      gtk_box_pack_start(GTK_BOX (box1), edit1, FALSE, FALSE, 10);

      button1 = gtk_button_new_with_label("Calculate!");
      g_signal_connect (button1, "clicked", G_CALLBACK (calc_sin), NULL);
      gtk_box_pack_start(GTK_BOX (box1), button1, FALSE, FALSE, 10);

      label1 = gtk_label_new("result");
      gtk_box_pack_start(GTK_BOX (box1), label1, FALSE, FALSE, 10);

      button_exit = gtk_button_new_with_label ("Exit");
      gtk_box_pack_start(GTK_BOX (box1), button_exit, FALSE, FALSE, 10);
      g_signal_connect_swapped (button_exit, "clicked", G_CALLBACK
(gtk_widget_destroy), main_window);

      gtk_widget_show_all (main_window);
}

int
main (int    argc,
      char **argv)
{
    GtkApplication *app;
    int status;
      app = gtk_application_new ("org.gtk.the_sin", G_APPLICATION_FLAGS_NONE);
      g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
      status = g_application_run (G_APPLICATION (app), argc, argv);
      g_object_unref (app);
      return status;
}

 А теперь откомпилируем-отлинкуем этот код разными методами и выполним его. Предполагается, что cmake и meson уже установлены.

Сначала сделаем это "традиционно":

#gcc calc_sin.c `pkg-config  --cflags --libs  gtk+-3.0` -lm -o calc_sin_bin

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

В едитбокс вводим величину в радианах, нажимаем на кнопочку "Calculate!" и вместо слова "result" увидим величину синуса введенного значения.

Теперь соберем нашу программу с помощью CMake.
Создадим файл CMakeLists.txt следующего содержания:

cmake_minimum_required (VERSION 2.6)

project (calc_sin_prj)
find_package (PkgConfig REQUIRED)
pkg_check_modules (GTK3 REQUIRED gtk+-3.0)
include_directories (${GTK3_INCLUDE_DIRS})
link_directories (${GTK3_LIBRARY_DIRS})
add_executable(calc_sin_bin calc_sin.c)
add_definitions (${GTK3_CFLAGS_OTHER})
target_link_libraries (calc_sin_bin ${GTK3_LIBRARIES} m)

Этот файл в данном случае должен быть в директории с нашим исходником. Далее делаем такую последовательность команд:

#mkdir cmakebuilddir
#cd cmakebuilddir
#cmake ..
#cmake --build .

Теперь соберем нашу программу с помощью meson.
Создадим файл meson.build следующего содержания:

project('calc_sin_meson', 'c')
cc = meson.get_compiler('c')
m_dep = cc.find_library('m', required:false)
deps = [dependency('gtk+-3.0'), m_dep]
executable('calc_sin_bin', 'calc_sin.c', dependencies : deps)

 Делаем такую последовательность команд:

#meson setup mesonbuilddir
#cd mesonbuilddir
#meson compile

Во всех трех случаях получаем бинарник  calc_sin_bin с одинаковою функциональностью. Обратите внимание, что этот бинарник создается в случае meson в директории mesonbuilddir , а в случае CMake в директории  cmakebuilddir. Получается что дерево исходников находится отдельно, а все рабочие файлы каждой системной сборки (мезон и симэйк) находятся только в своей поддиректории соответственно. Аккуратно и логично.

понедельник, 29 июня 2015 г.

Как обменять значения двух переменных без использования третей в языке си

Приведу пять способов, без комментариев:
switch2val(int *a, int* b){
    *a=*b+*a;
    *b=*a-*b;
    *a=*a-*b;
}

switch2val(int *a, int *b){
     *a=*a+*b-(*b=*a);
}

switch2val(int *a, int *b){
     *a=*a^*b;
     *b=*a^*b;
     *a=*b^*a;
}

switch2val(int *a, int *b){
     *a=*b-~*a-1;
     *b=*a+~*b+1;
     *a=*a+~*b+1;
}

switch2val(int *a, int *b){
      *a=*b+*a,*b=*a-*b,*a=*a-*b;
}

суббота, 3 января 2015 г.

Строковые типы в Windows, часть 2

Если мы работаем со строками STL в Windows и хотим быть независимыми от значения переменной _UNICODE (то есть писать код независимый от того работаем ли мы со строками UNICODE или нет), то тогда можно воспользоваться таким куском кода:
#ifdef _UNICODE
#define tstring wstring
#else
#define tstring string
#endif
Если воспользоваться фактом, что std::string и std::wstring являются typedef шаблона класса std::basic_string, то можно сделать так:
namespace std
{
 typedef basic_string<TCHAR> tstring; 
}

Наиболее общее решение выглядит так:

#include  <tchar.h>
#include  <string>
#include  <fstream>
#include  <sstream>
namespace std
{
typedef basic_string<TCHAR> tstring;
typedef basic_ostream<TCHAR> tostream;
typedef basic_istream<TCHAR> tistream;
typedef basic_iostream<TCHAR> tiostream;
typedef basic_ifstream<TCHAR> tifstream;
typedef basic_ofstream<TCHAR> tofstream;
typedef basic_fstream<TCHAR> tfstream;
typedef basic_stringstream<TCHAR> tstringstream;
}
Взято отсюда.

среда, 21 августа 2013 г.

Понятие виджетов GNOME/GTK+

Попробуем коротко описать понятие виджета GTK. При изучении программирования на GTK необходимо понимать, что такое "программирование на Си в объектно-ориентированной манере". Речь идет не о объектном Си (языке программирования Objective C), а о об написании программ на "обычном" языке Си, но держа при этом написании в уме основные концепции ООП.

Объектно-ориентированный Си

  • Объектно-ориентированное программирование - это всего лишь метод организации данных и кодов. Библиотеки GNOME и GTK+ написаны на С, и их API состоит только из вызовов функций С. Тем не менее, код написан в объектно-ориентироанном стиле. Объектная ориентация не является частью языка С и ее пришлось имитировать. Имеется несколько характеристик объектов, относящихся к GNOME и GTK+, самыми важными из которых следует считать инкапсуляцию, наследование и методы.
  • Доступ к инкапсулированной информации может быть получен только посредством обращений к функциям, специально разработанным для этих целей. Эти функции называются методами.
  • Код, описывающий объект, называтся классом. Класс, из которого образуется другой класс, называется базовым. Все классы изначально происходят из GtkObject. Каждая структура включает в виде первого элемента полную структуру своего базового класса.
  • Для создания нового объекта используется метод. Все создающие объект функции имеют в своем имени слово new. Обычно функции, создающие  какой-либо виджет (кнопку, чекбокс и т.п.), возвращает указатель на структуру GtkWidget, а не структуру кнопки или чекбокса. Это возможно благодаря полиморфизму. Полиморфизм означает, что любой объект может рассматриваться в качестве одного из своих базовых классов.
  • Когда вызывается метод для работы с существующим объектом, адрес этого объекта передается как первый аргумент.
  • Методы всех классов в иерархии вызываются при использовании специальных макросов приведения типов данных. Для каждого виджета в GNOME и GTK+ имеется макрос приведения типов данных. Эти макросы делают несколько больше, чем просто приведение типов: во время работы приложения удостоверяют правильность приведения типов.
При программировании на  GTK важно понятие о событиях и их диспетчеризации.

 Последовательность диспетчеризации событий.

  • Происходит событие.
  • Соответствующая информация отправляутся менеджеру окон.
  • Менеджер окон имеет адрес очереди событий для каждого окна. Он преобразовывает полученные данные в стандартный для Х формат и ставит их в очередь, связанную с окном в которое послано событие.
  • Главный цикл приложения  использует низкоуровневую функцию системы Х для чтения событий из очереди. По идентификатору окна, присланному вместе с сообщением, программа определяет, какой из виджетов должен получить сигнал. Затем однп из функций GTK+ преобразует информацию в сигнал и передает его виджету.
  • Для каждого виджета существует функция, которая получает все поступающие сигналы.
  • Виджет просматривает список функций обратного вызова, которые связаны с определенным сигналом, и вызывает все эти функции.
Для создания сигнала можно применять функции g_signal_emit() g_signal_emit_by_name(). Соответствующие функции с префиксом gtk_ вместо g_ устарели и не рекомендуются для применения в "свежем" коде.Каждая функция обратного вызова имеет два общих параметра, но многие из функций имеют еще дополнительные параметры. Прототип самой простой функции обратного вызова выглядит так: 
void cb(GtkWidget*, gpointer); 
Если имеются дополнительные параметры, то они вставляются между двумя параметрами этого прототипа. Также кроме пустого типа могут возвращаться типы gint и boolean. На самом нижнем уровне создание события - это создание события Xevent. Xevent содержит тег, идентифицирующий окно, для которого это событие предназначено. Каждому событию соответствует своя структура. Каждая структура определена в виде двух частей. Первая - это собственно сама структура, а вторая - оператор typedef для этой структуры. Имена различаются только первым символом: имя структуры начинается символом подчеркивания.GdkEvent - это объединение нескольких структур событий. Чтобы облегчить задачу определения типа события и соответствующей ей структуры, первым полем во всех структурах является поле type. Для доступа к данным события напрямую можно выполнить приведение типа объединения к типу структуры. Какое именно приведение надовыполнить определяем из поля type.Информация о каждом событии содержится в структуре GSignalQuery. Ее поля заполняются с помощью функции g_signal_query().
typedef struct {
    guint signal_id;
    const gchar *signal_name;
    GType itype;
    GSignalFlags signal_flags;
    GType return_type; /* mangled with G_SIGNAL_TYPE_STATIC_SCOPE flag */
    guint n_params;
    const GType *param_types; /* mangled with G_SIGNAL_TYPE_STATIC_SCOPE flag */
} GSignalQuery;
У каждого виджета есть внутренние установки, которые прикладная программа может читать или записывать.Приложению необходим интерфейс для обращения к этим установкам (аргументам)  внутри указанного виджета. То есть, чтобы прочитать или записать одно из этих значений, программа должна знать имя виджета, имя переменной и тип данных этой переменной. Итак, каждый аргумент имеет тип данных и права чтения/записи. Большинство аргументов имеют права и чтения и записи.Есть два способа установить значение аргументв внутри виджета.Есть фунции, закрепленные к определенному аргументу, который можно изменять с помощью этой функции. Соответственно есть фукция для чтения этого аргумента.Второй способ заключается в использовании структуры GtkArg, у которой три поля: GtkType - определяет тип данных, указательна строку, определяющую имя аргумента, и объединение различных типов данных.Когда виджет рождается и проходит свой путь от шаблона бит в памяти до графического объекта на экране, то происходят процессы создания, реализации, преобразования и отображения. При уничтожении виджета происходят: скрывание, уничтожение соответствия, деактивизация и разрушения. Виджет может скрываться и появляться вновь. При перемещении из одного окна в другое происходят уничтожение реализации, а потом реализация.Указанным этапам соответствуют такие функции:
*_new()
gtk_widget_destroy()
gtk_widget_unref()
gtk_widget_show()
gtk_widget_hide()
gtk_widget_map()
gtk_widget_unmap()
gtk_widget_realize()
gtk_widget_unrealize()
У виджетов есть также до пяти так называемых стилей (состояний):
GTK_STATE_NORMAL
GTK_STATE_ACTIVE
GTK_STATE_PRELIGHT
GTK_STATE_SELECTED
GTK_STATE_INSENSITIVE
Для первого "философского" понимания, что такое виджет GTK - этого достаточно.

четверг, 8 августа 2013 г.

Строковые типы в Windows

В Windows существует возможность писать код, который будет откомпилирован и корректно работать со строками или в ANSI представлении или юникоде, в зависимости от значения переменной _UNICODE. Рассмотрим это на примере.
char* string1 = "ANSI string";// не зависит от значения _UNICODE
wchar_t* string2 = L"UNICODE string";// не зависит от значения _UNICODE
LPTSTR string3=_T("or ANSI or UNICODE string"); // зависит от значения _UNICODE
LPTSTR string4=TEXT("or ANSI or UNICODE string"); // то же самое
LPTSTR -это макрос, который во время работы препроцессора раскрывается либо в wchar_t* либо в char*, в зависимости от _UNICODE. То же самое относится к макросам _T и TEXT - они раскрываются в L либо в "ничего".
Приведем таблицу соответсвия некоторых таких макросов и типов, а также наиболее типичных функций, работающих со строками. Имена типов комбинируются из достаточно простых и понятных составляющих:
LP означает long pointer,
C - constant,
STR - string,
WSTR - wide character string
, но все равно можно легко запутаться, поэтому эта табличка будет полезна:
В первой колонке написаны макросы которые раскрываются в значения во второй колонке, если мы работаем с ANSI строками или в значения в третей колонке, если мы работаем с юникодом. Вобщем, если мы хотим писать "универсальный" код, нам надо вместо функций или типов пользоваться соответствующими макросами.
 Более обильная информация по подобной теме представлена в MSDN в разделе Generic-Text Routine Mappings.

понедельник, 25 марта 2013 г.

Основы MPI

Что такое MPI? Смотрим википедию. Здесь же мы придержимся нашего жанра "шпоргалки".
Шесть "главных" MPI команд:
  • MPI_Init(int *argc, char ***argv)
  • MPI_Finalize()
  • MPI_Comm_size(MPI_Comm comm, int *size)
  • MPI_Comm_rank(MPI_Comm comm, int *rank)
  • MPI_Get_processor_name(char *name, int *resultlen)
  • MPI_Send(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm)
  • MPI Recv(void* buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Status *status)
Основные понятия MPI:
  • типы MPI:
    MPI_CHAR, MPI_SHORT, MPI_INT, MPI_LONG, MPI_UNSIGNED_CHAR, MPI_UNSIGNED_SHORT, MPI_UNSIGNED, MPI_UNSIGNED_LONG, MPI_FLOAT, MPI_DOUBLE, MPI_LONG_DOUBLE
  • MPI коммуникатор
  • MPI tag
  • MPI Processes
Проиллюстрируем это обилие информации классическим приветствием миру. Создаем файл helloworld.c следующего содержания:
#include
#include
int main(int argc, char ** argv) {
    int size,rank;
    int length;
    char name[80];

    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD,&rank);
    MPI_Comm_size(MPI_COMM_WORLD,&size);
    MPI_Get_processor_name(name,&length);
    printf("Hello MPI! Process %d of %d on %s\n",size,rank,name);
    MPI_Finalize();
    return 0;
}
Компилируем и запускаем на выполнение:
#mpicc helloworld.c -o helloworld
#mpirun -np 2 ./helloworld
Запустить на выполнение можно так:
#mpirun -np 2 -machinefile hostfile ./helloworld
где hostfile - файл с таким, например, содержанием:
aa slots=4
bb slots=4
cc slots=4

(взято с мануала к команде mpirun) aa, bb, cc - имена узлов. Поварируйте число после ключа -np, узнаете много интересного.
Рассмотрим передачу сообщений между процессами. Отредактируем файл helloworld.c следующим образом:
#include
#include
int main(int argc, char ** argv) {
    int size,rank;
    int length;
    char name[80];
    int dest = 0;
    int tag = 999;

    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD,&rank);
    MPI_Comm_size(MPI_COMM_WORLD,&size);
    MPI_Get_processor_name(name,&length);
    printf("Hello MPI! Process %d of %d on %s\n",size,rank,name);
    if (rank != 0 ) { /* I’m a client */
        MPI_Send(name,80,MPI_CHAR,dest,tag,MPI_COMM_WORLD);
    }else{ /* I’m the server (rank == 0) */
        MPI_Status status;
        int source;
        for(source = 1; source < size; source++) {
 
MPI_Recv(name,80,MPI_CHAR,source,tag,MPI_COMM_WORLD,&status);
            printf(" mesg from %d of %d on %s\n",source,size,name);
        }
    }   
    MPI_Finalize();
    return 0;
}
Компилируем и запускаем на выполнение теми же командами, что и первый пример.
Оба примера компилировались и тестировались на компьютере с Debian Wheezy:
#uname -a
Linux myhost 3.2.0-4-686-pae #1 SMP Debian 3.2.39-2 i686 GNU/Linux

среда, 13 марта 2013 г.

Дискретное преобразование Фурье в fftw3 и в CUDA

Если вам вдруг понадобилось вычислить дискретное преобразование Фурье, то для этой цели прекрасно подойдут два инструмента: http://www.fftw.org/ и CUDA. К достоинствам первого можно отнести его открытость, специализация именно на преобразовании Фурье, предельная простота установки. 
Рассмотрим для начала пример с использованием fftw.
Создадим файл fftw3.c следующего содержания:
#include <stdlib.h>
#include
<stdio.h>
#include <fftw3.h>
Компилируем его с помощью следующей команды:
#gcc fftw3.c -o fftw3 -lfftw3 -lm
 Как видите, если убрать код, выводящий данные на стандартный вывод, то остальной код, выполняющий главную функциональность, будет смотреться предельно просто и ясно. Всего несколько строчек. Для завершения картины запускаем программу:
#./fftw3
и изучаем вывод. Должны увидеть, что обратное преобразование восстанавливает входные данные для прямого преобразования.
Далее рассмотрим решение этой же задачи средствами CUDA. К недостаткам этого метода можно отнести не всегда простую установку CUDA  и обязательное наличие видеокарты, поддерживающую эту технологию. К достоинствам отнесем всю мощь данной технологии. Код взят из примеров, поставляемых вместе с тулкитом с сайта NVIDIA. Называется он (код, с помощью которого была написана программа, исходники которой далее приводятся) иронично simpleCUFFT. Хотя простоты там, на мой взгляд нет совсем, потому что пример, показывающий как пользоваться преобразованием Фурье, завален кодом, делающим конволюцию сигнала с фильтром (зачем это людям, изучающим CUDA?), и выковырять пару строчек, которые и делают прямую задачу примера, было для меня не просто.  За деревьями леса не видно. Поэтому, думаю, этот пост будет полезен.
Итак, создаем файл truelySimpleFFT.cu следующего содержания:
#include<stdlib.h>
#include
<stdio.h>
#include<string.h>
#include<math.h>

#include
<cuda_runtime.h>
#include <cufft.h>

typedef float2 Complex;
#define N_ELEM 10
int
main(int argc, char **argv)
{
    Complex *h_signal;
    Complex *d_signal;
    int mem_size;
    cufftHandle plan;
   
    printf("[truely simpleCUFFT] is starting...\n");
    //Выделяем память для входных данных на хосте
    h_signal = (Complex *)malloc(sizeof(Complex) * N_ELEM);

    //Инициализируем входные данные
    for (unsigned int i = 0; i < N_ELEM; ++i){
        h_signal[i].x = (float)i;
        h_signal[i].y = 0;
        printf("%f\t%f\n", h_signal[i].x, h_signal[i].y);
    }  
   
    //Выделяем память для входных данных на видеокарте и копируем их туда
    mem_size = sizeof(Complex) * N_ELEM;     
    cudaMalloc((void **)&d_signal, mem_size);                                  
    cudaMemcpy(d_signal, h_signal, mem_size, cudaMemcpyHostToDevice);                 
     
    //Собственно выполняем преобразование Фурье
    printf("Transforming signal cufftExecC2C\n");
    cufftPlan1d(&plan, N_ELEM, CUFFT_C2C, 1);                        
    cufftExecC2C(plan, (cufftComplex *)d_signal, (cufftComplex *)d_signal, CUFFT_FORWARD);
   
    //Копируем результат вычисления с видеокарты на хост
    cudaMemcpy(h_signal, d_signal, mem_size, cudaMemcpyDeviceToHost);
    for (unsigned int i = 0; i < N_ELEM; ++i)
        printf("%f\t%f\n", h_signal[i].x, h_signal[i].y);
   
    //Прибираем за собой
    cufftDestroy(plan);
    free(h_signal);
    cudaFree(d_signal);
    cudaDeviceReset();
   
    exit(0);
}
 
Компилируем его с помощью следующих двух команд:
#nvcc  -o simpleCUFFT.o -c truelySimpleFFT.cu
#g++ -o simpleCUFFT simpleCUFFT.o -lcudart -lcudart -lcufft
Необходимо отметить следующее. Если вы устанавливали SDK с сайта NVIDIA "руками", то вам надо вставить в выше приведенные команды ключи -L и -I с соответствующими путями к заголовочным файлам и библиотекам, которые вы указывали при установке (а также nvcc с полным путем). Я устанавливал с помощью репозитария (пользуюсь Дебиан) и в моем случае надо вводить команды как написано выше.
Также обратите внимание на подобие кода, выполняющего преобразование Фурье в обоих примерах.
Запускаем на выполнение командой:
 #./simpleCUFFT
Обе программы компиллировались и ваполнялись на Debian GNU/Linux 7.0 (wheezy).

воскресенье, 10 марта 2013 г.

Простейшая генерация случайных чисел в языке Си

Приведем простейшую функцию генерации случайных чисел в языке Си в диапазоне от нуля до единицы:
double
frand ( void ){
  double value;
  value = ( ( double ) rand ( ) / ( RAND_MAX ) );
  return value;
}
У Кернигана и Ричи используется конструкция ( ( double ) rand ( ) / ( RAND_MAX + 1 ) ), но она может привести к отрицательным величинам у случайных чисел.

Простейшая работа со временем в языке Си

Допустим нам необходимо получить строку выводящую время на "человеческом" языке. Как исходный шаблон можем использовать следующую функцию:
void
timestamp ( void )
{
    static char time_buffer[100];
    const struct tm *tm;
    size_t len;
    time_t now;

    now = time ( NULL );
    tm = localtime ( &now );
    len = strftime ( time_buffer, 100, "%d %B %Y %I:%M:%S %p", tm );
    printf ( "%s\n", time_buffer );

    return;
}

Пусть теперь нам надо посмотреть, как много времени забирает выполнение того или иного участка кода. Для решения этой задачи будет удобным следующий пример:
#include<stdio.h>
#include
<stdlib.h>
#include<time.h>

Расширения языка Си в CUDA

Имеется четыре типа расширений языка Си в CUDA. Это:
  1. Квалификаторы типа функции, определяющие, где эта функция будет выполняться - в центральном процессоре или на видеокарте, и возможно ли вызывать эту функцию из центрального процессора или видеокарты.
  2. Квалификаторы типа переменных, определяющие распределение памяти для этих переменных на видеокарте.
  3. Директива, определяющая как ядро выполняется на видеокарте.
  4. Четыре встроенных переменных, определяющих размерность грида, размерность блока, индекс блока и индекс нити.
Рассмотрим эти расширения подробней.
I.Квалификаторы типа функций
  1. __device__ квалификатор говорит, что функция выполняется на видеокарте и может быть вызвана только из видеокарты.
  2. __global__ квалификатор объявляет функцию выполняемой в  центральном процессоре и вызываемой только процессором. Квалифицирование функции только __host__ аналогично объявлению функции без какого-то ни было квалификатора. Однако функцию можно квалифицировать комбинацией __host__ __device__. Тогда функция будет откомпилирована и для центрального процессора и для видеокарты.  
 Ограничения:
  •  функции квалифицированные __device__ и __global__ не поддерживают рекурсии.
  •  функции квалифицированные __device__ и __global__ не могут декларировать внутри себя статические переменные.
  • функции квалифицированные __device__ и __global__ не могут иметь переменное количество аргументов.
  • функции квалифицированные __device__ не могут вызываться по их адресу.
  • функции не могут быть одновременно квалифицированы как __global__ и __host__.
  • функции квалифицированные как __global__ обязаны возвращать пустой тип.
  • функции квалифицированные как __global__ должны специфицировать  свою конфигурацию выполнения.
  • функции квалифицированные как __global__ выполняются синхронно.
  • параметры функций квалифицированных как __global__ передаются через общую память в видеокарту и ограничены 256-ю байтами.
II. Квалификаторы переменных.
  1. __device__ квалификатор говорит, что переменная размещается на видеокарте. Может использоваться совместно с другими квалификаторами типа переменных. Если таковых нет, то это означает, что переменная размещена в глобальной памяти, имеет время жизни равное времени жизни приложения и доступна из нитей в гриде и с центрального процессора через библиотеку времени исполнения.
  2. __constant__ квалификатор опционально используемый предыдущим квалификатором объявляет, что переменная размещается в области постоянной памяти, имеет время жизни равное времени жизни приложения и доступна из нитей в гриде и с центрального процессора через библиотеку времени исполнения.
  3. __shared__ квалификатор опционально используемый с  __device__ квалификатором объявляет, что перменная размещается в общей памяти блока нитей, имеет время жизни равное времени жизни блока и доступна только из нитей данного блока.
Ограничения:
  • Эти квалификаторы не допустимы для членов struct и union, в формальных параметрах функций и локальныхперменных внутри функций, что выполняются на центральном процессоре.
  • __shared__ и __shared__ не могут использоваться вместе.
  • __shared__ и __shared__ переменные подразумеваются статическими.
  • __constant__ переменные не могут использоваться внутри видеокарты, только на центральном процессоре. Поэтому они имеют область видимости файла.
  • __shared__ переменные не могут иметь инициализацию как часть их декларации.
III. Конфигурация выполнения.
Любой вызов функции __global__ должен специфицировать конфигурацию выполнения этой функции. Конфигурация выполнения функции определяет размерность грида и блоков, которые будут использоваться при вызове функции на видеокарте. Эта конфигурация задается аргументами между тройными угловыми скобками. <<>>. Эта конструкция помещается между именем функци и списком передаваемым в функцию списком "обычных" аргументов.
Описание аргументов в угловых скобках следующее:
  1. Dg - имеет тип dim3 и определяет размерность и длину грида так что выражение Dg.x*Dg.y равно числу запущенных блоков.
  2. Db - имеет тип dim3 и определяет размерность и длину каждого блока, так что выражение Db.x*Db.y*Db.z равно числу нитей в каждом блоке.
  3. Ns - имеет тип size_t и определяет количество байтов в общей памяти, которая выделяется динамически при данном вызове функции дополнительно к ее статической памяти. Ns - необязательный аргумент со значением по умолчанию раным нулю.
Аргументы конфигурации выполнения вычисляются раньше  "обычных" аргументов функции.
IV. Встроенные переменные
  1. gridDim - переменная типа dim3. Содержит размерность грида.
  2. blockIdx - переменная типа uint3. Содержит индекс блока в гриде.
  3. blockDim - переменная типа dim3. Содержит размерность блока.
  4. threadIdx - переменная типа uint3. Содержит индекс нити в блоке.
Ограничения:
  • не допустима операция получения адреса от любой встроенной переменной.
  • не допустима операция присваивания для любой встроенной переменной.

суббота, 26 января 2013 г.

Cовместное использование языков Си и Фортран.

В UNIX системах языки Си и Фортран могут использоваться вместе, так как между этими языками возможны прямые вызовы функций. При этом, правда, необходимо тщательно учитывать совместимость типов передаваемых аргументов. Обычно соответствие между типами в Си и Фортране можно представить так:
signed char    INTEGER*1
short               INTEGER*2
int                   INTEGER
long                INTEGER*4
float                REAL
double            DOUBLE PRECISION
void sub_        SUBROUTINE SUB()
float  fun_()     REAL FUNCTION FUN
Также следует помнить о следующем: 
  • в Фортране аргументы в функции всегда передаются ссылками;
  • В Си массивы передаются через адрес;
  • Порядок индексации многомерных массивов различен для Си и Фортрана - в Си элементы массива располагаются построчно, в Фортране - по столбцам;
  • Имена функций в Фортране имеют в своем конце "скрытый" знак подчеркивания '_' (его нет в исходном тексте, но он добавляется компилятором), поэтому, если некая фунция вызывается из Фортрана как fun(), то эта же функция из Си вызывается как fun_() ; 
  • В языке Си длина строки определяется положением нулевого байта, в Фортране же строки имеют фиксированную длину. Поэтому при передаче строки из Си кода в Фортран необходимо передавать также ее длину. В случае же передачи строки из Фортран кода в Си необходимо добавить нуль в конец строки;
Рассмотрим два случая: когда си код вызывается из фортрана и , наоборот, когда из фортран кода вызывается си код.
Файл cCode1.c:
#include<stdio.h>
void
c_function_(){
     printf("Hello from C code!\n");
}
 Файл fortranCode1.f90:
program hello
    implicit none
    call c_function()
    write (*,*)"Hello from FORTRAN code!"
end program hello
 Компилируем и запускаем на выполнение:
#gfortran -O2 -g -o fortranCode1.o -c fortranCode1.f90
#gcc -O2 -g -o cCode1.o -c cCode1.c
#gcc -L /usr/lib/gcc/i486-linux-gnu/4.7/ -lgfortran fortranCode1.o cCode1.o -o hello1
#./hello1
Нужно, чтобы присутствовала библиотека libgfortran.so
 /usr/lib/gcc/i486-linux-gnu/4.7/ - это путь, по которомуона у меня лежит. У вас может быть другой путь.
Обратный случай:
Файл cCode2.c:
#include<stdio.h>
void
main(){
     fortran_function_();
     printf("Hello from C code!\n");
} 
Файл fortranCode2.f90:
subroutine fortran_function
    implicit none
    write (*,*)"Hello from FORTRAN code!"
end subroutine fortran_function
Компилируем и запускаем на выполнение:
#gfortran -O2 -g -o fortranCode2.o -c fortranCode2.f90
#gcc -O2 -g -o cCode2.o -c cCode2.c
#gcc -L /usr/lib/gcc/i486-linux-gnu/4.7/ -lgfortran fortranCode2.o cCode2.o -o hello2
#./hello2
Теперь сделаем вызов функции с передачей параметров разных типов.
Файл cCode3.c:
#include<stdio.h>
void
c_function_(signed char* a1, short* a2, int* a3, long int* a4){
     printf("in called c function: \n%d\t%d\t%d\t%ld\n", *a1, *a2, *a3, *a4);
}
 Файл fortranCode3.f90:
program hello
    implicit none
    integer*1 a1
    integer*2 a2
    integer*4 a3
    integer*8 a4
    a1=1
    a2=22
    a3=333
    a4=4444
    call c_function(a1, a2, a3, a4)
end program hello
 #gfortran -O2 -g -o fortranCode3.o -c fortranCode3.f90
#gcc -O2 -g -o cCode3.o -c cCode3.c
#gcc -L /usr/lib/gcc/i486-linux-gnu/4.7/ -lgfortran fortranCode3.o cCode3.o -o hello3
#./hello3
 Файл cCode4.c:
#include<stdio.h>
void
main(){
     signed char a1 = 1;
     short            a2 = 22;
     int                 a3 = 333;
     long              a4 = 4444;
     fortran_function_(&a1, &a2, &a3, &a4);
} 
Файл fortranCode4.f90:
subroutine fortran_function(f1, f2, f3, f4)
    implicit none
    integer*1 f1
    integer*2 f2
    integer*4 f3
    integer*4 f4
    write (*,100)f1,f2,f3,f4
100 format(4i5)
end subroutine fortran_function
#gfortran -O2 -g -o fortranCode4.o -c fortranCode4.f90
#gcc -O2 -g -o cCode4.o -c cCode4.c
#gcc -L /usr/lib/gcc/i486-linux-gnu/4.7/ -lgfortran fortranCode4.o cCode4.o -o hello4
#./hello4
Теперь продемонстрируем передачу символьных строк из Си в Фортран и обратно.

Файл cCode5.c:
#include<stdio.h>
void
     c_function_(char* string){
     printf("%s\n", string);
}
 Файл fortranCode5.f90:
program hello
    implicit none
    character*37 string
    string="Created in fortran, outputed from C!"
    string(37:37)=char(0)
    call c_function(string)
end program hello
#gfortran -O2 -g -o fortranCode5.o -c fortranCode5.f90
#gcc -O2 -g -o cCode5.o -c cCode5.c
#gcc -L /usr/lib/gcc/i486-linux-gnu/4.7/ -lgfortran fortranCode5.o cCode5.o -o hello5
#./hello5 
Теперь наоборот. Сформируем строку в Си, а напечатаем в Фортране.
Файл cCode6.c:
#include<string.h>
void
main(){
     char string[37];
     int length = sizeof(string);
     strncpy(string, "Created in C, outputed from Fortran!", length);
     fortran_function_(string, &length);
}
Файл fortranCode6.f90:
subroutine fortran_function(string, length)
    implicit none
    character*(*) string
    integer length
    write(*,100)string(1:length)
100 format(a)
    return
end subroutine fortran_function
#gfortran -O2 -g -o fortranCode6.o -c fortranCode6.f90
#gcc -O2 -g -o cCode6.o -c cCode6.c
#gcc -L /usr/lib/gcc/i486-linux-gnu/4.7/ -lgfortran fortranCode6.o cCode6.o -o hello6
#./hello6
Все примеры протестированы в Debian Wheezy.

пятница, 19 сентября 2008 г.

10 заповедей Си программисту от Henry Spencer

1. Ты должен пользоваться lint-ом почаще и внимать его изречениям с большим вниманием ибо воистину часто он видит больше тебя и его суждения более верны твоих.
2. Не следуй за null-указателем ибо хаос и безумие ждут тебя на том месте.
3. Ты должен явно приводить все аргументы функций к ожидаемому типу, если они не есть уже этим типом, даже если твое искусство убеждено, что это необязательно. Чтобы не постигла тебя более жестокая участь, чем ты ожидаешь.
4. Если твой заголовочный файл недостаточно точно описывает возвращаемый тип твоей библиотечной функций, то ты должен декларировать их с большей тщательностью, чтобы не случилось с твоей программой вопиющего зла.
5. Ты всегда должен следить за границами всех строк (а они в действительности массивы), ибо уж точно, что там где ты напечатаешь "foo", кто-нибудь когда-нибудь напечатает "supercalifragilisticexpialidocious".
6. Если функция была объявлена как возвращающая код ошибки, ты должен обработать этот код. О да. Даже если это утроит размер твоего кода и доставляет боль твоим печатающим пальцам. Ибо, если ты думаешь "это никогда не случиться со мной", то воистину будешь наказан за свою надменность.
7. Ты должен изучать твои библиотеки и прилагать усилия, чтобы не изобретать их повторно без причин, чтобы твой код мог быть коротким и читаемым, а дни твои были результативными и протекали в удовольствии.
8. Ты должен делать цели и структуру твоей программы ясной для твоих соратников использованием Единственно Истинного Стиля Ставить Скобки, нравится тебе это или нет. Ибо лучше, чтобы твои силы были используемы для решения проблемы а не для создания нового красивого препятствия для понимания.
9. Твои внешние идентификаторы должны быть уникальны только в пределах первых шести букв, хотя это неприятное правило надоело и годы его необходимости затянулись пред тобою, чтобы не рвал твои волосы и не доходил до безумия в тот роковой день, когда решишь запустить твою программу на старой системе.
10. Ты должен отречься от подлой ереси, которая провозгласила "весь мир - VAX" и не общаться с погруженными во тьму еретиками, которые цепляються за это варварское верование, чтобы дни твоей программы могли быть долгими даже не смотря на то, что дни твоей машины коротки.

вторник, 2 сентября 2008 г.

K&R конспект

Кто из нас, написав (вернее переписав) классическую программу "Hello, world!", не почувствовал себя программистом? А далее, после создания приложения выводящего окно на экран или табулирующего результаты расчетов, уже почти состоявшимся девелопером? И, тем не менее, даже когда мы создаем не совсем тривиальные приложения, мы можем не знать (или не осозновать?) многих тонкостей языка, на котором мы пишем. Особенно это касается языка Си. Потому что за его простотой кроется "мощь" и "гибкость". Так прост он или(и) мощен? На этот вопрос нет ответа. Как впрочем и ответа на вопрос: а что же такое "мощь", "гибкость" (и т.п.) предметов, если можно так выразиться, которые относятся к программированию? Хотя в айтишной литературе любят такие слова, но кроме "интуитивного", другого понимания нет. Программирование - это точная наука. А значит оно требует точных определений, а не размытых образов. Конечно же это мое имхо.
Иллюзию простоты языка Си придает тот факт, что основной труд, если хотите первоисточник, по языку Си а именно книга создателей Си Кернигана и Ритчи "Язык программирования Си" очень небольшой. Особенно если сравнивать с прочими фолиантами. Краткость - сестра таланта. Избыточности практически нет. Ну или почти нет. Тем не менее, за кажущейся простотой кроется много тонкостей или, по другому, моментов, которые очевидны и просты лишь на первый взгляд. Либо много неочевидных моментов, которые просто незаметны.
Но избыточность все-таки можно надумать. Вырвав с мясом тексты программ, фрагменты текста, которые заменимы соответствующими манами и предложения, которые ну уж совсем просты (опять таки это мой взгляд, но планку "простоты" я постарался опустить как только можно ниже), можно получить короткий, но весьма полезный на мой взгляд, перечень абзацев (предложений, положений, постулатов - тут я очень затрудняюсь с выбором слова), которые очень полезны для просмотра после прочтения этой книги. И могут заменить повторное ее чтение, тем более, не смотря на ее краткость, за день ее не прочитаешь. То есть этот пост - это попытка написать добротный конспект этой книги. Получилось или нет - судить читателю.
Текст будет меняться. Постараюсь придерживаться духа опенсорс. Основная версия этого текста находится тут. Комментарии принимаются в этом блоге. Приветствую любые комментарии.
  • Диапазоны значений int и float зависят от используемой машины.
  • Базовые типы для данных: char - один байт, short, long, double - размеры этих объектов зависят от машины.
  • Из базовых типов можно создать: массивы, структуры, объединения, указатели на объекты базовых типов, функции, возврашающие значения этих типов.
  • printf не является частью языка.
  • #define имя подставляемый_текст
    точка с запятой в конце не ставится.
  • Простейшие из функций для чтения и записи одного символа:
    c=getchar(); putchar(c);
  • В while и for условие проверяется до того как выполняется тело цикла.
  • Символ, заключенный в одинарные кавычки представляет собой целое значение (символьная константа).
  • Под терминами "формальный аргумент" и "фактический аргумент" будут пониматься как параметр и аргумент соответственно.
  • В Си все аргументы функций передаются "по значению".
  • Внешняя переменная должна быть определена, причем только один раз, вне любой функции, в этом случае ей будет выделена память. Она должна быть объявлена во всех функциях, которые ею пользуются. Объявление содержит сведения о типе переменной. Объявление может быть явным (extern) или неявным (нужная информация получается из контекста).
  • Чтобы функция могла пользоваться внешней переменной ее надо объявить extern. Если определение внешней переменной в файле расположено выше функции (где она используется), то объявление extern можно не использовать. Если же определение находится в другом файле, то extern обязательно.
  • Из соображений совместимомти пустой список аргументов выключает проверки на соответствие аргументов. Поэтому, чтобы явно указать отсутствие аргументов вместо someFunction() надо писать someFunction(void).
  • Удобно собрать все объявления внешних переменных и функций в один header и помещать его в начало каждого исходного файла.
  • Определение располагается в месте, где переменная создается и ей отводится память.
  • Объявление - там, где фиксируется природа переменной, но память не отводится.
  • Не начинайте имена переменных с "_", так как многие имена переменных библиотечных програм начинаются с этого знака.
  • Для внутренних имен значимыми являются первые 31 символ. Для имен функций и внешних переменных число значимых символов может быть больше 31, так как эти имена обрабатываются ассемблером и загрузчиком а языком (компиллятором) не контролируются.
  • Уникальность внешних имен гарантируется только в пределах 6 символов.
  • Базовые типы:
    char - 1 байт;
    int, float, double;
    Квалификаторы: short, long, signed, unsigned;
    short int - ("int" можно опустить) 2 байта;
    long int - ("int" можно опустить) 4 байта;
    2 байта <= short <= int <= long >= 4 байта;
  • Возможные комбинации:
    unsigned char;
    unsigned int;
    unsigned short;
    unsigned long;
    signed char;
    signed int;
    signed short;
    signed long;
    float <= double <= long double;
  • Если l, L, u, U, ul или UL - стоят после цифры, то это целые константы.
    Если f, F, l или L - константы с плавающей точкой.
  • '0'=48, '\n' - символьная (целая) константа.
  • 0x 0X - стоит перед цифрами. Это константа в шестнадцатеричном представлении.
    '\000' '\x00' - запись восьмеричного или шестнадцатеричного кодов соответственно.
  • Полный набор эскейпов: \a, \b, \f, \n, \r, \t, \v, \\, \?, \', \", \000, \xhh;
    '\0' тождественно 0 (ноль).
  • Константные выражения вычисляются во время компилляции, а не выполнения.
  • Строковая константа или строковый литерал - это нуль или более символов, заключенных в ".
  • Во внутреннем представлении строки в конце обязательно присутствует '\0'.
  • strlen вычисляет длину без учета '\0'.
  • 'x' - не то же, что "x"!
  • Константы перечисления - это список целых констант.
  • Первое имя в enum имеет значение 0. enum - удобный способ присваивать константам имена, причем значения констант генерируются автоматически. Разрешается объявлять переменные типа enum, но компиллятор не обязан проверять входят ли присваиваемые значения в тип enum. Но возможность такой проверки делает enum лучше #define. Отладчик может печатать значения переменных типа enum в символьном виде.
  • Инициализация неавтоматической переменной осуществляется только один раз - перед тем как программа начнет выполняться. При этом начальное значение должно быть константным выражением. Явно инициализируемая автоматическая переменная получает начальное значение на входе в функцию или блок. Ее начальным значением может быть любое выражение. Без инициализации там будет мусор.
  • Внешние и статические переменные по умолчанию имеют значение 0.
  • Квалификатор: const.
  • Реакция на попытку изменить константу зависит от компиллятора.
  • Оператор % к float и double не применяется.
  • В какую сторону будет усечена дробная часть при выполнении / и каким будет знак результата % с отрицательными числами, зависит от машины.
  • Автоматически производятся лишь те преобразования, которые без потери информации превращают операнды с меньшим диапазоном значений в операнды с большим диапазоном. Выражения, в которых могла бы теряться информация влекут предупреждение, но они допустимы.
  • При преобразовании char в int происходит одно из двух: либо старший бит char "распространяется" либо слева добавляются только нули. Что произойдет - зависит от машины.
  • Гарантируется, что любой символ из стандартного набора печатных символов никогда не будет отрицательным числом. Произвольный char на одних машинах может быть отрицательным, на других - положительным. Для совместимости переменные char, в которых хранятся несимвольные данные, следует специфицировать явно как signed или unsigned.
  • Операторы сравнения (например <) и логические выражения, перемежаемые операторами && и ||, определяют выражение-условие, которое имеет значение 1, когда оно истинно, и 0, когда оно ложно. Однако функции, подобные isdigit, в качестве истины могут выдавать любое ненулевое значение. В общем случае, если бинарный оператор имеет разнотипные операнды, прежде чем он будет выполняться, "низший" тип будет повышаться до "высшего". Результат будет иметь высший тип. Операторы типа float не приводяться автоматически к типу double. Пусть значение типа int - 16 битов, а типа long - 32 бита. Тогда: unsigned int повышается до signed long поэтому -1L<1u>1UL.
  • При присваивании значение правой части приводиться к типу левой части, который и является типом результата.
  • Тип char превращается в int путем распространения знака или другим (?) способом.
  • Тип long int преобразуется в short int или в значение типа char путем отбрасывания старших разрядов.
  • Тип float переводится в тип int отбрасыванием дробной части.
  • Если double переводится во float, то значение либо округляется, либо обрезается. Это зависит от реализации.
  • Так как аргумент в вызове функции есть выражение, при передаче его функции также возможно преобразование типа. При отсутствии прототипа функции аргументы типа char и short переводятся в int, а float - в double. Вот почему в примерах этой книги объявлялись аргументы типа int или double, даже тогда, когда в вызове функции использовались аргументы типа char или float.
  • Заметим, что операция приведения всего лишь вырабатывает значение указанного типа, но саму переменную не затрагивает.
  • n = n & 0177; // обнуляет все разряды, кроме младших семи.
  • Следует отличать побитовые и логические операторы.
  • Операторы << и >> сдвигают влево или вправо левый операнд на число битовых позиций, задаваемое правым операндом, который должен быть неотрицательным. Сдвиг влево (<<) эквивалентен умножению на соответствующую степень двойки. Сдвиг вправо беззнаковой величины всегда сопровождается заполнением освобождающихся разрядов нулями. Сдвиг вправо знаковой величины на одних машинах происходит с распространением знака (арифметический сдвиг), на других - с заполнением освобождающихся разрядов нулями (логический сдвиг). Таким образом, объявление операнда правого сдвига unsigned, гарантирует, что освобождающиеся биты будут заполняться нулями независимо от машины. n = n & ~077; // обнуляет последние шесть разрядов. Заметим, что форма записи ~077 является машинно независимой.
  • Типом и значением любого выражения присваивания являются тип и значение его левого операнда после завершения присваивания.
  • Если второе и третье выражения тернарного опреатора ?: принадлежат разным типам, то тип результата определяется соответствующими правилами преобразования вне зависимости от того какое выражение вычисляется - второе или третье.
  • Си подобно многим языкам не фиксирует очередность вычисления операндов оператора (за исключением "&&", "||", "?:" и ","). Очередность вычисления аргументов функции также не определена. Обращения к функциям, вложенные присваивания, инкрементные и декрементные операторы дают "побочный эффект", проявляющийся в том, что при вычислении выражения значения некоторых переменных изменяются. Лучший порядок вычислений определяется архитектурой машины.
  • Выражение становиться инструкцией, если в конце его поставить точку с запятой. Фигурные скобки используются для объединения объявлений и инструкций в составную инструкцию или блок. С точки зрения синтаксиса эта конструкция воспринимается как одна инструкция. Переменные могут быть объявлены внутри любого блока. После закрывающей скобки в конце блока точка с запятой не ставится.
  • Запись if(выражение) и if(выражение != 0 ) эквивалентны.
  • Отсутствие else-части в одной из вложенных друг в друга if-конструкций приводит к неоднозначному толкованию. else связывают с ближайшим if, у которого нет своего else. Если нужна другая интерпретация, то пользуются фигурными скобками. Совет: вложенные if всегда обрамляйте фигурными скобками.
    Пример:
    if(выражение)

    for()
    if(выражение){
    блок выражений
    }
    else
    выражение;

    else относится к if в теле цикла! Хотя, на первый взгляд к внешнему if.
  • break и return - наиболее распространенные средства выхода из переключателя.
  • Совет (при пользовании переключателем switch): даже в конце последней ветви помещайте инструкцию break, хотя с точки зрения логики в ней нет никакой необходимости.
  • Инструкция:
    for(выражение1;выражение2;выражение3)
    инструкция
    эквивалентна конструкции:
    выражение1;
    while(выражение2){
    инструкция
    выражение3;
    }

    если не считать отличий в поведении инструкции continue. При отсутствии выражение1 или выражение3 считается, что их просто нет в конструкции цикла. При отсутствии выражение2 предполагается, что его значение как бы всегда истинно.
  • Отличие цикла for в си от от DO-цикла в Фортране (и for-цикла в Паскале) в том, что значенте идекса цикла и его предельного значения могут изменяться внутри цикла и значение индекса после выхода из цикла всегда определено.
  • Пара выражений, разделенных запятой, вычисляется слева направо. Типом и значением результата является тип и значение результата правого выражения. Запятые, разделяющие аргументы функции, переменные в объявлениях и пр. (?) не являются операторами-запятыми и не обеспечивают вычисление слева направо. Запятые-операторы более всего уместны в конструкциях, которые тесно связаны друг с другом, а также в макросах, в которых многоступенчатые вычисления должны быть выражены одним выражением.
  • Инструкция break вызывает немедленный выход из самого внутреннего из объемлющих ее циклов или переключателей (for, while, do-while, switch). Инструкция continue вынуждает ближайший объемлющий цикл (for, while, do-while) начать следующий шаг итерации (немедленный переход к проверке условия для while и do-while и для for - выполнение выражение3). Внутри переключателя switch, расположенного в цикле, инструкция continue вызовет переход к следующей итерации этого цикла. То есть она применяется к циклам, но не к переключателю.
  • Определение любой функции имеет следующий вид:
    тип-результата имя-функции(объявления аргументов) { объявления и инструкции; }
    Если тип результата опущен, то предполагается, что функция возвращает значение типа int.
  • Любая программа - это просто совокупность определений переменных и функций. Связи между функциями осуществляются через аргументы, возвращаемые значения и внешние переменные. В исходном файле функции могут располагаться в любом порядке. Исходную программу можно разбивать на любое число файлов, но так, чтобы ни одна из функций не оказалась разрезанной.
  • За словом return может следовать любое выражение. Если потребуется, то выражение будет приведено к возвращаемому типу функции.
    return выражение;
    Выражение можно заключить в скобки, но они необязательны.
  • Вызывающая фукция вправе проигнорировать возвращаемое значение. Выражение в return может отсутствовать. Также управление возвращается в вызывающую функцию без результирующего значения также и в том случае, когда вычисления достигли конца (последней закрывающей фигурной скобки функции).
  • Объявление и определение функции должны соответствовать друг другу. Если в одном исходном файле сама функция и обращение к ней не соответствуют друг другу, то компилятор сгенерирует ошибку. Но если вызываемая функция была скомпилируема отдельно, то несоответствие не будет обнаружено, что приведет на этапе выполнения к бессмысленному результату. (Разговор идет только про возвращаемые значения?) Одной из причин подобного несоответствия может быть ситуация, когда отсутствует прототип вызываемой функции и тогда функция неявно объявляется при первом своем появлении в каком-нибудь выражении.
  • Если в выражении встретилось имя, нигде ранее не объявленное, за которым следует открывающаяся скобка, то такое имя по контексту считается именем функции, возвращающей результат целого типа. При этом относительно аргументов ничего не предполагается.
  • Если в объявлении функции аргументы не указываются, то и в этом случае считается, что об аргументах ничего не известно, и все проверки на соответствие параметров будут выключены. Это сделано для совместимости. Но этой особенностью лучше не пользоваться. Если надо явно указать отсутствие аргументов у функции, то используется слово void.
  • При преобразовании типов возможна потеря информации, и некоторые компиляторы предупреждают об этом. Оператор приведения явно указывает на необходимость преобразования типа и подавляет любое предупреждающее сообщение.
  • Сами функции всегда являются внешними объектами, поскольку в Си запрещено определять функции внутри других функций. По умолчанию одинаковые внешние имена, используемые в разных файлах, относятся к одному и тому же внешнему объекту (функции). В стандарте это называется external linkage. В этом смысле внешние переменные похожи на области COMMON в Фортране.
  • В выражении func()-func(); очередность обращения к func() не определена, поэтому, учитывая некоммутативность оператора "-", результат может быть неверен.
  • Параметры функции фактически являются локальными переменными.
  • Если на внешнюю переменную нужно сослаться до того, как она определена, или если она определена в другом файле, то ее объявление должно быть помечено словом extern.
  • Объявление объявляет свойства переменной (прежде всего ее тип), а определение, кроме того, приводит к выделению для нее памяти.
  • На всю сосвокупность файлов, из которых состоит исходная программа, для каждой внешней переменной должно быть одно-единственное определение. Другие файлы, чтобы получить доступ к внешней переменной, должны иметь в себе объявление extern.
  • В определениях массивов необходимо указывать их размеры, что в объявлениях extern не обязательно.
  • Инициализировать внешнюю переменную можно только в определении.
  • Указание static, примененное к внешней переменной или функции, ограничивает область видимости соответствующего объекта концом файла.
  • Как и автоматические, внутренние статические переменные локальны в функциях, но отличаются от первых тем, что существуют постоянно.
  • Объявление register сообщает компилятору, что данная переменная будет интенсивно использоваться. Компилятор может проигнорировать это указание. Объявление register может применяться только к автоматическим переменным и к формальным параметрам функции. Располагаться в регистрах может лишь небольшое число переменных, причем только определенных типов. Применительно к регистровой переменной независимо от того, выделен на самом деле для нее регистр или нет, не определено понятие адреса.
  • Объявления переменных (вместе с инициализацией) разрешено помещать не только в начале функции, но и после любой левой фигурной скобки.
  • Переменные static инициализируются только одиин раз при первом входе в блок.
  • При отсутствии явной инициализации для внешних и статических переменных гарантируется их обнуление. Автоматические и регистровые переменные имеют неопределенные начальные значения ("мусор").
  • Для внешних и статических переменных инициализирующие выражения должны быть константными, при этом инициализация осуществляется только один раз до наяала выполнения программы. Инициализация автоматических и регистровых переменных выполняется каждый раз при входе в функцию или блок. Для таких переменных инициализирующее выражением может служить любое выражение, использующее ранее определенные значения, включая даже и вызовы функций. В сущности, инициализация автоматической переменной - это более короткая (?) запись инструкции присваивания.
  • Если размер массива не указан, то длину массива компилятор вычисляет по числу заданных инициализаторов. Если количество инициализаторов меньше числа, указанного в определении длины массива, то для внешних, статических и автоматических (а какие ж еще бывают?) переменных оставшиеся элементы будут нулевыми.
  • char pattern[]="ould"; char pattern[]={'o','u','l','d','\0'}; Первая запись является более коротким вариантом вторной.
  • #define заменяет одни текстовые последовательности на другие.
  • Включения (делаемые директивой #include ?) необязательно являются файлами. Технические детали того, как осуществляется доступ к заголовкам, зависят от реализации.
  • Область видимости имени, определенного в #define, простирается от данного определения до конца файла. Подстановка (#define) осуществляется только для тех имен, которые расположены вне текстов, заключенных в кавычки.
  • #define dprint(expr) printf(#expr "=%g\n", expr)
    Внутри фактического аргумента каждый знак " заменяется на \" ну а каждая \ на \\.
  • Оператор ## позволяет в макрорасширениях конкатенировать аргументы. Правила вложенных использований этого оператора не определены.
  • Константное целое выражение, заданное в строке #if, не должно содержать ни одногооператора sizeof или приведения к типу и ни одной enum-константы.
  • #if defined(var) эквивалентно #ifdef var
    #if !defined(var) эквивалентно #ifndef var
  • В качестве обобщенного указателя предлагается тип void* (до введения стандарта ANSI эту роль выполнял тип char*).
  • Применительно к любой машине верны следующие утверждения:
    1) один байт может хранить значение типа char;
    2) два байта - short;
    3)четыре байта - long;
  • Указатель - это, как правило, два или четыре байта.
  • Унарный оператор * есть оператор косвенного доступа.
  • Синтаксис объявления переменной и функции "подстраивается" под синтаксис выражений, в которых эта переменная может встретиться.
  • По определению значение переменной или выражения типа массив есть адрес нулевого элемента массива. Следующие записи эквивалентны:
    pa=&a[0];
    pa=a;

    Также эквивалентны такие записи:
    pa[i]
    *(pa+i)

    так как вычисляя первую запись, Си преобразует ее во вторую.
    И такие:
    &a[i]
    a+i
  • Между ипменем массива и указателем, выступающим в роли имени массива, есть одно различие. Указатель - это переменная, поэтому можно написать pa=a или pa++. Но имя массива не является переменной и записи вроде a=pa и a++ не допускаются.
  • Если имя массива передается функции, то последняя получает в качестве аргумента адрес его начального элемента. Внутри вызываемой функции этот аргумент является локальной переменной, содержащей адрес. Формальные параметры char s[]; и char *s; в определении функции эквивалентны. Если функции в качестве аргумента передается имя массива, то она может рассматривать так, как ей удобно - либо как имя массива, либо как указатель, и поступать с ним соответственно. Она даже может использовать оба вида записи, если это покажется уместным и понятным.
    Функции можно передавать часть массива. Если есть уверенность, что элементы массива существуют, то возможно индексирование и в "обратную" сторону по отношению к нулевому элементу. Нельзя "выходить" за границы массива и тем самым обращаться к несуществующим объектам.
  • Если p есть указатель на некоторый элемент массива, то p++ увеличивает p так, чтобы он указывал на следующий, а p+=i - на i-й элемент после того, на который указывал ранее.
  • С помощью malloc можно работать с массивом у которого нет имени.
  • Указатели и целые не являются взаимозаменяемыми объектами. Константа нуль - единственное исключение из этого правила: ее можно присвоить указателю, и указатель можно сравнивать с нулевой константой. Вместо цифры нуль можно писать NULL (определена в ).
  • Если указатели указывают на элементы одного и того же массива, то к ним можно применять операторы отношения и их можно вычитать один из другого. Если элементы не из одного массива, то результат не определен. Исключение: можно использовать адрес несуществующего "следующего за массивом" элемента.
  • Указатели и целые можно складывать и вычитать. Допускается также вычитание указателей, если они указывают на элементы из одного массива. Разрешено присваивание одного указателя другому того же типа. Других операций с указателем производить не допускается.
  • Указателю одного типа нельзя присвоить указатель другого типа, не выполнив предварительно операции приведения (исключение - указатели *void).
  • Число символов в строке может быть слишком большим, чтобы хранить его в переменной типа int. Тип ptrdiff_t достаточный для хранения разности (со знаком) двух указателей, определен в . Имеется также тип беззнакового целого size_t, возращаемого оператором sizeof.
  • Существует различие между следующими определениями:
    char amessage[] = "some string";
    char *pmessage = "some string";

    Первое - это массив с последним элементом '\0'. Отдельные символы внутри массива могут изменяться, но amessage указывает всегда на одно и то же место в памяти. pmessage - указатель на строковую константу. Сам он может изменяться. Если попытаться изменить содержимое константы, то результат неопределен.
  • *p++ = val; /*поместить val в стек*/
    val = *--p; /*извлечь из стека и поместить в val*/
  • Если двумерный массив передается некоторой функции, то ее можно определить несколькими путями:
    f(int massive[n][m]){...}
    f(int massive[][m]){...}
    f(int (*massive)[m]){...}

    В общем случае только первое измерение можно не задавать, все другие специфицировать обязательно.
  • Рассмотрим два определения:
    int a[m][n];
    int *b[n];

    а является истинным массивом - для всех его элементов будет выделена память, а вычисление смещения элемента будет вестись по формуле n*строка+столбец. Для b же определено только n указателей, причем без инициализации. Инициализация должна задаваться явно, либо статически, либо в программе. Важное преимущество массива указателей в том, что строки такого массива могут иметь разные длины. Указатель из такого массива может вообще ни на что не указывать.
  • По соглашению argv[0] есть имя вызываемой программы, так что значение argc никогда не бывает меньше единицы. Стандарт требует, чтобы argcargv[argc] всегда был пустым указателем. argv - указатель на массив указателей, поэтому мы можем работать с ним как с указателем, а не как с индексируемым массивом. Заметим, что *++argv является указателем на аргумент-строку, а (*++argv)[0] - его первым символом, на который можно сослаться и другиим способом: **++argv.
  • За словом struct может следовать имя, называемое тегом структуры. Тэг дает название структуры данного вида и далее может служить кратким обозначением той части объявления, которая заключена в фигурные скобки. Перечисленные в структуре переменные называются элементами (членами) структуры. Единственно возможный опреации над структурами - это их копирование, присваивание, взятие адреса с помощью &, и осуществление доступа к ее элементам. Копирование и присваивание включают в себя предачу функциям аргументов и возврат ими значений. Структуры нельзя сравнивать.
  • Число элементов массива struct можно вычислить по формуле:
    someType someMassive[];
    размер someMassive / размер stuct someType
  • Выражения sizeof объект и sizeof (имя типа) выдают целые значения, равные размеру указанного объекта или типа в байтах. (строго говоря, sizeof выдает беззнаковое целое, тип которого size_t определен в )
  • Препроцессор не обращает внимания на имена типов, поэтому оператор sizeof нельзя применять в #if. В #define выражение препроцессором не вычисляется, поэтому можно использовать оператор sizeof в #define.
  • Не обязательно и возможно опасно, если malloc или ее заместитель не может быть объявлен как функция, возращающая void*. Явное приведение типа может скрыть случайную ошибку.
  • Объявляемый в typedef тип стоит на месте имени переменной в обычном объявлении, а не сразу за словом typedef. С точки зрения синтаксиса слово typedef напоминает класс памяти - extern, static и т.д.
  • Следует подчеркнуть, что объявление typedef не создает объявления нового типа, а сообщает новое имя уже существующему типу. Нового смысла эти имена не несут, они объявляют переменные в точности с теми же свойствами, как если бы те были объявлены напрямую без переименования типа. Фактически typedef аналогичен #define c тем лишь отличием, что при интерпретации компилятором он может справиться с такой текстовой подстановкой, которая не может быть обработана препроцессором.
  • Для применения typedef существуют две причины:
    1)Параметризация программы. Если с помощью typedef объявить типы данных, которые, возможно, являются машинно-зависимыми, то при переносе программы на другую машину потребуется внести изменения только в определения typedef.
    2)Желание сделать более ясным текст программы.
  • Объединения позволяют хранить разнородные данные в одной и той же области памяти без включения в программу машинно-зависимой информации. Цель введения в программу объединения - иметь переменную, которая бы на законных основаниях хранила в себе значения нескольких типов. В том случае, если нечто запомнено как значение одного типа, а извлекается как значение другого, результат зависит от реализации. Фактически объединение - это структура, все элементы которой имеют нулевое смещение относительно ее базового адреса и размер которой позволяет поместиться в ней самому большому ее элементу, а выравнивание этой структуры удовлетворяет всем типам объединения.Операции, применимые к структурам, годятся и для объединений (присваивание, копирование, взятие адреса, доступ к отдельным элементам).
  • Инициализировать объединение можно только значением, имеющим тип его первого элемента.
  • Битовое поле - некоторое множество битов, лежащих рядом внутри одной, зависящей от реализации единицы памяти, называемую здесь "словом". Синтаксис определения полей и доступа к ним базируется на синтаксисе структур. Почти все технические детали, касающиеся полей, в частности, возможность поля перейти границу слова, зависят от реализации. Поля могут не иметь имени, с помощью такого поля организуется пропуск нужного количества бит. Ширина, равная нулю, используется, когда требуется выйти на границу следующего слова. На одних машинах поля размещаются слева направо, на других - наоборот. Поля можно определять только с типом int, а для того чтобы обеспечить переносимость, надо явно указывать signed или unsigned. Поля не могут быть массивами и не имеют адресов, т.е. оператор & к ним не применим.
  • Простейший механизм ввода - чтение одного символа из стандартного ввода функцией int getchar(void)
  • EOF обычно равно -1, но, чтобы не зависеть от конкретного ее значения, обращаться к ней следует по имени.
  • prog предписывает программе prog считывать символы из infile. Причем переключение ввода делается так, что сама программа не замечает подмены. В частности строка "" не будет включена в аргументы командной строки argv.
  • FILE - это имя типа, наподобие int, а не тег структуры. Оно определено с помощью typedef.
  • Полный набор "системных" типов находится в <sys/types.h>.
  • Для каждой из машин существует тип, предъявляющий самые большие требования на выравнивание, и, если по некоему адресу допускается размещение объекта этого типа, то по нему можно разместить и объекты всех других типов.