Wataru

При инициализации переменных это обычно не используют. Ну, происходит тут преобразование типа - ошибки быть не может. Это лишь немного снижает читабельность кода и все.

Вот когда вы константы передаете в какие-то перегруженные функции, где имеет значение unsigned ли ей передан или signed, или есть разница между float и double, то тогда - да, надо писать.

Вот эти побитовые сдвиги работли бы, если бы вы хранили число в двоичной системе счисления. Допустим, по 16 бит в каждом int. В таком виде вычисления побыстрее будут немного, но при выводе надо переводить число в 10-ую систему счисления. Судя по примеру ответа, вы храните по 3 десятичных знака в каждой ячейке. Т.е. у вас основание системы счисления 1000. И тут нужны сдвиги не битовые, а тысячные (которых не существует).

Вообще, основной цикл умножения должен быть примерно такой:

for (i = 0; i < len1; ++i)
  for (j = 0; j < len2; ++j) 
    c[i+j] += a[i]*b[j];

И потом надо сделать все переносы. Вот тут и происходят сдвиг на i позиций (в системе счисления 1000) - это то самое +i в индексе у массива результата. И вместо выполнения прибавления, когда бит равен 1, тут происходит умножение на a[i]. В битовом случае оно как раз вырождается в умножение на 1 или 0 - прибавление или пропуск прибавления.

Это работает даже если вы в массивах a,b храните по несколько бит в каждой ячейке, или даже десятичных знаков. Это просто умножение в столбик в произвольной системе счисления.

Правда, тут проблема, что вот такое вот умножение, если вы храните по 32 бита, оно переполнится, и ответ надо в 64-битном типе получать. И даже если вы храните по 16 бит, то сумма может переполниться из-за большого количества слагаемых. Ну это решается выполнением переноса сразу же:

const int BASE = 1000; // База системы счисления. Оно же максимальное число в ячейке +1.
for (i = 0; i < len1; ++i) {
  int carry = 0;
  for (j = 0; j < len2; ++j) {
    carry += c[i+j] + a[i]*b[j];
    c[i+j] = carry % BASE; 
    carry /= BASE;
  }
  int i = len1+len2-1;
  while (carry > 0) {
    carry += c[i];
    c[i] = carry % BASE;
    carry /= BASE;
    ++i;
  }
}

Если это произвольный тип, то какой у него размер? Какими значениями вы его заполнять-то пытаетесь?

А так, скорее всего вам подойдет функция memset. Какими-нибудь нулями все заполнить - отлично можно. Хоть там int, хоть char, хоть float.

Все у вас правильно написано, вы запутались.

Ваша функция, как и стандартная, работает с радианами и выдает такой же результат от того же аргумента Pi*30/180=Pi/6.

Посмотрите, ведь в result и во второй строке вывода вы передаете один и тот же агумент и получаете один итот же 0.500000. Только во второй строке у вас вместо Pi написано 3.1415265.

Какая-то проблема из-за чего один и тот же элемент удаляется дважды, судя по всему.

Вижу сразу ошибку в delete_node: Если вершина в списке всего одна, произойдет фингя: this_list->last не обновится, да и next_node->prev несуществующее будет переписано.

Руками. Циклом на x_len-2 итераций. Раз у вас там, судя по коду, есть обрамление, то лучше гнать цикл с 1.

for (int j = 1; j < x_len-1; ++j) {
  map[i][j] = ' ';
}

Еще, конечно, можно извратиться с memset, но лучше ненадо. Это тяжело читать и можно налажать запросто.

Гугли "GDI+"
Это библиотека под винду, которя позволяет рисовать в окнах/на экране.
Надо получить DeviceContext для экрана, и там рисовать что хочешь.

mas уже указатель. Массивы в C - указатели. Не надо & использовать где вы его возвращаете. Только в этом случае оно скомпилируется, но работать не будет, потому что mas - локальный массив. По выходу из функции это будет указатель на отчищенную память. Надл выделять массив через malloc.

Внешний цикл по итерацийм не распараллелить, потому что каждая итерация зависит от предыдущей.

Внутри можно циклы по i объединить все в один.

Ну и параллельте цикл по i через pragma omp for.

Если стоит visual studio, там есть утилита spy++. Она мониторит виндовые сообщения, приходящие выбранному окну.

Запустите ваше приложение, натравите на него spy++, ткните в кнопку, чтобы появилось меню, и смотрите, какие сообщения и с какими параметрами приходят. Потом повторите их же в коде через postMessage.

Ошибка в том, что вы проверяете на четность сами элементы, а не их индексы. Вы суммируете нечетные числа. Если надо каждое второе число брать, то проверяйте на четность n.

Я так понял, вы там перебираете 8 соседей клетки на замкнутом поле (после последней строки идет первая, перед певрой идет последняя и так же для столбцов). Вам поможет опреация взятия остатка от деления (она же деление по модулю).

Можно так:

for (int dx = -1; dx <= 1; ++dx) {
  for (int dy = -1; dy <= 1; ++dy) {
    if (dx == 0 && dy == 0) continue;
    int nx = (i + dx + height) % height;
    int ny = (j + dy + SIZE) % SIZE;
    neighbours += proc_states[iter][nx * SIZE + ny];
  }  
}

Или можно завести

const int dx[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const int dy[8] = { 1, 1, 0, -1, -1, -1, 0, 1};
...
for (int k = 0; k < 8; ++k) {
  int nx = i + dx[k];
  int ny = j + dy[k];
  ...
}

Можно не заводить временные переменные и ужать код до двух строк.

В конструкции (i + dx + SIZE) % SIZE есть лишний +SIZE, ибо -1 % SIZE == -1 и чтобы для 0 предыдущее значение было SIZE-1 надо прибавить лишний SIZE под модулем.

Теоретически, ++i быстрее. Практически - нет, потому что компиляторы могут и то и другое соптимизировать в одни и те же ассемблерные инструкции в большинстве случаев. Исключение, если инкримент используется в выражении. Но тогда они не взаимозаменяемы. Еще может быть случай, если i какого-то странного типа и инкрименты перегружены и криво написаны. Или если оптимизация отключена при компиляции. Или у вас доисторический компилятор.