0
Я имею в виду чем эти проги отличаются для программиста — с точки зрения трудоемкости и принципиальной достижимости результата
…
И я так понимаю, что по большому счету — ни чем!

Ничесе «ни чем». С точки зрения разработки писать на MFC на порядок сложнее чем на том же .NET. Даже примитивная задача, типа создать диалог с несколькими контролами, который адекватно ресайзится — потребует от вас (на MFC) написания кучи примитивного кода, придется самому писать обработчик ресайза и двигать элементы. В то время как на WinForms или WPF (да и, наверное, в большинстве современных GUI фреймворках) все это решается парой кликов мышкой в дизайнере форм. Я уже не говорю о том, насколько мал функционал предоставляемый MFC по сравнению с .NET и сопутствующими технологиями.
  • avatar
  • e_mc2
  • 03 ноября 2015, 21:21
0
Дык х64 семерка в принципе не может работать с драйверами 32 бит, эмуляция 32-х битного режима есть только для прикладных программ, но не для драйверов. Разве нет?
  • avatar
  • e_mc2
  • 03 ноября 2015, 21:08
+3
Коллега, вот (скромный :) список того, что мне не хватает в других терминалах

Из низкоуровневых вещей (из того что не решается на уровне простого прикладного приложения):

1. Работа в режиме сниффера, то есть прослушивать трафик через порт (об этом уже писали).

2. Корректная работа с «виртуальными портами». Сейчас «честный» СОМ порт встретить тяжело, чаще мы имеем дело со всякими утройсвами типа USB CDC. Но ни один из известных мне терминалов не обрабатывает ситуации, когда USB устройство (которое эмулирует СОМ-порт) может быть на ходу отключено, потом подключено заново и т. д. Можно подключить такое устройство, открыть «виртуальный» СОМ порт, потом выдернуть устройство и ни один известный мне терминал никак не отреагирует на то, что порт «пропал». Это недостаток API, но думаю, на низком уровне это можно обойти отлавливая события PnP.

3. Макросы (уже было)

Из высоокоруровневых:
1. Возможность включения обработки управляющих последовательностей (хотя бы уровня ANSI терминала). Сейчас есть терминалы который либо умеют управляющие последовательности (тот же PuTTY) но не умеют просто показать данные как дамп в HEX (как Ваш), либо наоборот.

2. Возможность легко писать свои плагины, чтобы парсить протокол обмена (как это сделано в сниферах типа wireshark.

P. S. И я настоятельно рекомендую Вам игнорировать тех людей, который Вам рассказывают про «очередной велосипед, зачем оно ….», «а в Linux это можно сделать так… », «.NET не нужен ….», «а вот раньше было WinAPI были времена….». Просто делайте то, что Вам нравится и получайте удовольствие и опыт. Удачи Вам!
  • avatar
  • e_mc2
  • 01 ноября 2015, 21:31
+1
Чем более запутанней алгоритм шифрования, тем он более надежен

Это не так, скорее даже наоборот. Самый надежный шифр это шифр Вернама – который прост до безобразия и представляет собой простой XOR текста со случайным числом, которое и является ключом. Не смотря на простоту, это абсолютное оружие в мире криптографии, этот шифр неуязвим (правда число должно быть достаточно «случайным» и нельзя повторно использовать ключ, поэтому шифр и не удобен в повсеместном применении). А изобретение своих алгоритмов шифрования – это заведомо плохая идея.

Предложенный автором алгоритм (если я правильно понял его суть из описания), наверное, можно адаптировать для избыточного кодирования и последующего восстановления поврежденных данных. Хотя там тоже хватает стандартных алгоритмов: код Хемминга, Рида — Соломона
  • avatar
  • e_mc2
  • 30 октября 2015, 13:11
+4
Я бы Вам очень рекомендовал не использовать потенциально бесконечные циклы, типа
while (PIND.3==1)   // Пока датчик уровня разомкнут. Этот датчик нижний - он отбивает 30 литров в ёмкости. 
    {
         PORTD.5=0;      // Открываем клапан, набираем воду
    };
советую всегда в таких условиях считать время выполнения и обрабатывать таймаут. Грубо говоря, мы открыли кран и ожидаем, что емкость наполнится (сработает датчик уровня) за 10 мин. Если прошло 15 мин, а датчик не сработал – рассматривать это как аварию, и предусмотреть в программе обработку такой ситуации.
  • avatar
  • e_mc2
  • 04 октября 2015, 23:01
0
Касательно котиков – признаю свою ошибку, пример неправильный, я не подумав хотел показать несовместимость на конкретном типе (unsigned), хотя действительно можно все решить через базовый типы.

Но тут если процессор и компилятор нормальные, никаких алиасов не требуется. А общем случае стдинт всё равно не поможет.

Что значит «нормальные»?
  • avatar
  • e_mc2
  • 23 сентября 2015, 21:37
0
Да, тут я был неправ, забыв про гарантии диапазона и перестарался с аналогиями, пытаясь показать несовместимость типов на примере счетчика без переполнения.
  • avatar
  • e_mc2
  • 23 сентября 2015, 21:25
0
Минимальные размеры обеспечивает родная система типов

Я имел ввиду семейство синонимов подобных int_leastN_t, а система встроенных типов как раз ничего кроме выполнения условий sizeof(char) <= sizeof(int) <= … не обеспечивает.

А на практике, мы в большинстве случаев имеем дело с величинами, которые имеют определенную размерность (диапазон значений) и нам нужно обеспечить корректную работу в этом диапазоне.

Давайте предположим, что нам нужно написать программу, которая считает котиков. Из ТЗ нам известно, что количество котиков лежит в диапазоне 0 … 100000. Теперь нам нужно выбрать тип для внутреннего счетчика котиков. Если забить на переносимость кода и сконцентрироваться на, например, х86, то можно объявить тип как unsigned и забить на переносимость. Но мы не хотим на переносимость забивать мыж эмбеддеры, и точно знаем что в unsigned на AVR все наши котики не поместятся.

Мое предложение: давайте объявим тип счетчика как uint32_t, и это нам гарантирует, что на любой (даже неизвестной нам на данный момент платформе) нам хватит размерности счетчика. (для ценителей оптимизации можно предложить тип uint_fast32_t). При этом наш код будет понятен другим программистам, ибо данный тип общеизвестен. Более того нам не нужно самостоятельно его объявлять, окружение компилятора само подставит нужный для данной платформы встроенный тип.

Ваше предложение (если я Вас правильно понял): давайте объявим синоним catlib_cat_caunter_t, потом сами через директивы условной компиляции будем определять соответствующий встроенный тип для конкретной платформы. Зачем это делать самому если существуют специально стандартизированные для этого средства? Более того, потом мы захотим измерять массу котика (а она, как известно лежит в диапазоне 1… 1000) и что опять вводим новый тип catlib_cat_mass_t? А если нам нужно будет потом посчитать суммарную массу всех котиков – опять новый тип? Как-то дофига типов получается Вам не кажется?

Итого: если мы не используем синонимы мы не можем писать переносимый код т. к. не можем гарантировать нужную нам по условиям размерность (я надеюсь вы не рассматриваете всерьез идею делать все переменные unsigned long long ?). Писать свой тип для каждого конкретного случая – мы утоним в куче нафиг не нужных деклараций, которые нам еще к тому-же придётся самим адаптировать под каждую платформу.

Так вот, мало того, что использовали название для кучи говёных языков (С++ и пр.

Опять, при чем здесь С++ и другие «говеные» языки, мы ведь вроде конкретный вопрос обсуждаем?
  • avatar
  • e_mc2
  • 23 сентября 2015, 20:00
+1
Библиотеки часто вводят свои синонимы, чтобы повысить читаемость кода. Например, какая-то реализация файловой системы объявляет тип myfs_file_handle_t и это нормально, т. к. повышает читабельность, название типа подразумевает, что переменная содержит именно внутренний идентификатор файла.

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

Я понимаю, что во всяких модных оопах принято всё захардкодить…

Вы как всегда. Мы вроде обсуждаем типы из <stdint.h> и область их применения… Вот к чему Вы приплели сюда ООП, линуксовые репозитории и капиталистов?
  • avatar
  • e_mc2
  • 23 сентября 2015, 15:03
+3
Тайпдефы нужно использовать при необходимости
С этим никто не спорит.
Сделать в проекте тип mycoollib_smallindex_t, который будет 8 бит на межке и size_t на компе.

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

Просто отличная идея…

Всяких там u8, uint8, BYTE, tByte, min_data_type_8bit, нам мало, давайте пусть каждый программист придумает свое название, каким-то образом его где-то декларирует… Зато каждый программист сможет проявить свою творческую сторону, придумав свое, оригинальное название синониму. А всякие там стандартизации и правила именований – это для слабаков :)
  • avatar
  • e_mc2
  • 22 сентября 2015, 22:47
+1
А всё равно в каждой библиотеке свои типы — uLongf, GLuint, и т.д

Да, такая проблема действительно есть, и ее практически нельзя решить ибо существует огромное множество legacy code.

Но я не пойму, Вшу позицию, что Вы предлагаете?

Не использовать синонимы вообще? Плохая идея. Наличие синонимов при портировании позволяет в одном месте заменить определение, а не лазить по всему коду заменяя (где это нужно!) например «unsigned int» на «unsigned short». Да и с точки самодокумектации выражение
uint16_t counter;

выглядит лучше чем
unsigned int counter; //Реализация рассчитывает, что это 16-битная переменная, на забывайте об этом при портировании


Далее, можно игнорировать стандарт и придумать свой синоним, но зачем? Чтобы потом другие гадали что я подразумеваю под UnSh и в каком файле объявлена декларация данного типа?

(скажем, на МК для счётчика цикла используется байт, на компе — size_t и нужно вручную это обрабатывать)
Здесь я не понял, что вы хотели сказать. Если вы знаете, что максимальное значение итератора укладывается в 8 бит, но не хотите явно задавать размерность т. к. это может быть не оптимально по скорости для другой архитектуры можете использовать тот-же uint_fast8_t, он розвернетеся в соответствующий тип для данной архитектуры.

а небайтовые (которые вообще-то Си изначально прекрасно поддерживает) — вообще игнорит.
Не совсем игнорит, но какие другие варианты Вы можете предложить, чтобы сохранить одновременно универсальность и производительность?
  • avatar
  • e_mc2
  • 22 сентября 2015, 21:53
+2
Не восстановиться. Вы взяли только вертикальную проекцию F1, но проигнорировали горизонтальную, а она будет наклонять коптер вправо. Можно просто сложить вектора F1 и F2 и вы увидите, что результирующий вектор будет направлен вверх и вправо (как и в случае с перпендикулярной установкой двигателей)
  • avatar
  • e_mc2
  • 22 сентября 2015, 16:00
0
Увы, по данному вопросу ничего подсказать не могу, т. к. не интересовался расчетом ВМГ, пользовался готовыми решениями уровня «возьми такой-то двигатель, такой-то пропеллер …»
  • avatar
  • e_mc2
  • 22 сентября 2015, 15:59
+2
Я позволю себе высказать свое мнение касательно вопроса использования <stdint.h>

1. Зачем это нужно? Есть много задач, в которых нам нужно точно знать размерность переменной в битах. Нам ничего не мешает (зная особенности компилятора) создать свой синоним для типа. Но без стандартизации, мы получим, что каждый программист будет придумывать свое название для, например, без знаковой 16-битной переменной. В итоге получим, что в одном модуле этот тип называют u16, в другом — WORD, в третьем Uint16 (… uInt16, uSHORT …). Стандарт свел весь этот зоопарк названий к uint16_t

2. ОК, но ведь мы можем определить синоним uint16_t сами. Можем, но не должны. Если мы определим uint16_t как синоним int в каком-то «MyType.h», то это будет чудесно работать для AVR, но при попытке перенести код на ARM он скомпилируется, но будет работать не так как Вы ожидаете. Стандарт требует, чтобы компилятор (вернее окружение компилятора) сам корректно предоставлял (если это возможно) соответствующе синонимы типов.

3. Помимо типов с фиксированной размерностью <stdint.h> предоставляет другие синонимы. Например «быстрые типы» int_fastN_t. Это отельная тема, но этим стоит пользоваться в тех местах, где важна переносимость и, одновременно, производительность. Банальный пример – итераторы цикла.

Ну, и не следует забывать, что эти «типы» не являются серебряной пулей, их использование упрощает задачу переносимости кода, но только в рамках тех «гарантий» которые озвучены в стандарте. Это всего лишь синонимы, не стоит ждать от этого чего-то большего (например, при манипуляции с приведением указателей к другому типу).
  • avatar
  • e_mc2
  • 21 сентября 2015, 23:19
+1
Я имел виду именно регистры процессора, выравнивание доступа – это другая история.

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

Есть вещи, которые гарантируются стандартом, ну, например, что будет работать операция деления (хотя конкретный процессор может не иметь аппаратной поддержки деления). Есть вещи, когда стандарт нечетко определят требования (sizeof(char) <= sizeof(short) …), иногда стандарт вообще говорит, что компилятор может поступать на свое усмотрении (например сдвиг восьмибайтной переменной влево на 8 бит, это undefined behavior, и результат может быть любым).

Дык вот стандарт говорит, что если uint8_t определен – то это именно беззнаковый восьмибайтный тип. Не «около восьми» бит, а именно 8. Есть другие типы, например uint_least8_t – гарантирует, что он как минимум восьмибайтный, хотя его реальная размерность может быть любой, но не менее 8 бит.
  • avatar
  • e_mc2
  • 18 сентября 2015, 22:35
+1
Это я видел.

Мне запомнилась байка когда true был определён как-то типа (rand() % 50) и стоял комментарий
//меня уволили с работы, счастливой отладки, суки

:)
Это даже веселее чем
#define true ((__LINE__&15)!=15)


Вот по этому я и не верю, что ТІ позволяет себе определения
#define uint8_t uint16_t
Ибо это не просто несоответствие стандарту – это сознательная «подстава» которую будет очень тяжело выявить. Ведь сама идея введения подобных uint8_t типов — это именно гарантировать размерность, а не просто создать еще один синоним для типа с неопределенной размерностью. И приведенное в оригинале выражение не является undefined behavior.
  • avatar
  • e_mc2
  • 18 сентября 2015, 22:04
+1
видал я как в stdint.h от TI описан тип uint8_t:

Специально нашел в стандарте место где это описано:

Conversely, for each type described herein that the implementation does not provide, <stdint.h> shall not declare that typedef name nor shall it define the associated macros. An implementation shall provide those types described as ‘‘required’’, but need not provide any of the others (described as ‘‘optional’’).
Тип uint8_t не является обязательным (в отличии например от uint_least8_t), и если компилятор не может реализовать его корректную поддержку то декларация должна отсутствовать.
  • avatar
  • e_mc2
  • 18 сентября 2015, 15:59
+1
Вы когда-нибудь реально писали для 16-ти битных архитектур или у вас только в теории?

Если под 16-бит архитектурой вы имеете ввиду, что минимальный размер ячейки памяти 16-бит то не писал.

На практике все совсем не так, к сожалению.

а вот выражение (a<<1) восьмибитным быть не обязано и обычно соответствует разрядности архитектуры по умолчанию.

Данная ситуация четко описана в стандарте:

The result of E1 << E2 is E1 left-shifted E2 bit positions; vacated bits are filled with zeros. If E1 has an unsigned type, the value of the result is E1 × 2E2, reduced modulo one more than the maximum value representable in the result type.

Если uint8_t определен как беззнаковый 8-бит, то результат должен быть по модулю 0x100, исключение там есть только для знаковых типов.

#define uint8_t uint16_t

А вот это очень странно… Такое определение есть в стандартном stdint.h который поставляется с компилятором?
  • avatar
  • e_mc2
  • 18 сентября 2015, 15:44
0
С sizeof не все так просто. Согласно стандарту:

When sizeof is applied to an operand that has type char, unsigned char, or signed char, (or a qualified version thereof) the result is 1. When applied to an operand that has array type, the result is the total number of bytes in the array) When applied to an operand that has structure or union type, the result is the total number of bytes in such an object, including internal and trailing padding
  • avatar
  • e_mc2
  • 18 сентября 2015, 15:21
+1
Если я правильно понял, то для данного семейства МК компилятор определяет char как 8-битный, хотя фактически на C2X, будет для хранения использоваться 16 бит.

Результат будет одинаков – 0, т. к. это оговорено стандартом. Компилятор для данной платформы будет создавать дополнительный код (например, наложит маску 0xFF после операции сдвига) чтобы соответствовать стандарту и скрыть особенности архитектуры. Аналогично, например, в ARM все регистры 32битные, и компилятору иногда приходится генерировать дополнительный код чтобы, например, «эмулировать» переполнение 8-битного uint8_t при сложении (хотя сама операция сложения выполняется в 32-битном регистре, и никакого «реального» переполнения не происходит).

Теоретически, может быть ситуация, когда для какого-то МК какой-то компилятор определяет char как 16 бит (я такого никогда не встречал, но теоретически размерность char может быть любой ). Тогда (насколько я помню стандарт) в stdint.h должно отсутствовать определение uint8_t.

Другими словами – стандарт требует, чтобы uint8_t, если он определен, вел себя как беззнаковая 8-битная переменная (не важно как она будет обрабатываться и хранится в памяти). Если это невозможно (особенности платформы/компилятора) – то данный тип не должен быть определен в stdint.h Это гарантирует что приведенный вами код будет работать везде одинаково, либо компилятор выдаст ошибку на этапе компиляции.
  • avatar
  • e_mc2
  • 18 сентября 2015, 15:15