Вопросы по С/С++ (СИ)

[ПростоНуб]

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

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

Когда появилась OS/2, нужда в этой технике пропала, пока я не столкнулся с однозадачными МК.

Что касается исключений в C++, то не стоит их идеализировать. Бездумное их использование их очень сильно влияет на производительность программы. Поэтому, если производительность важна, лучше их использовать только в тех случаях, когда вероятность возникновения исключения близка к нулю. В последнем случае, исключения могут дать даже прирост производительности, по сравнению с классическими проверками.

[VladislavS]

Я исключения в микроконтроллере использую выставив ключ компилятора вот так: "-fno-exceptions".

Добавлено after 17 minutes 2 seconds:
Что-то мне сегодня не спалось утром, решил покомпилировать проект разными способами одним и тем же тулчейном. Сначала IDE-шечкой.

Спойлер

Код: Выделить всё

1>Linking VisualGDB/Release/F303-CDC-VGDB...
1>Map file saved to file://d:\!Projects\STM32-Discovery\Discovery-STM32F303\F303-CDC-VGDB\VisualGDB\Release\F303-CDC-VGDB.map
1>------------------- Memory utilization report -------------------
1>Used FLASH: 2812 bytes out of 256KB (1%)
1>Used SRAM: 112 bytes out of 40KB (0%)
1>Used CCMRAM: 0 bytes out of 8192 bytes (0%)
========== Сборка: успешно: 1, с ошибками: 0, без изменений: 0, пропущено: 0 ==========

Затем make в мастдайке

Спойлер

Код: Выделить всё

C:/CPP/GNU Tools ARM Embedded/8 2019-q3-update/bin/arm-none-eabi-size Bin\Release/Discovery-STM32F303.elf
   text    data     bss     dec     hex filename
   2808       4     112    2924     b6c Bin\Release/Discovery-STM32F303.elf

и в красноглазой среде

Спойлер

Код: Выделить всё

opt/gcc-arm-none-eabi-8-2019-q3-update/bin/arm-none-eabi-size Bin/Release/Discovery-STM32F303.elf
   text	   data	    bss	    dec	    hex	filename
   2808	      4	    112	   2924	    b6c	Bin/Release/Discovery-STM32F303.elf

Как и ожидалось, получил одинаковый результат. Причём в последних двух случаях даже побитово одинаковый, за разницей в направлении слэшей в пути к bинарнику.

За сим откланиваюсь и удаляюсь пить кофею

[ARV]

Хотелось бы услышать пару слов о цели этого эксперимента: что вы хотели узнать/проверить/уточнить?

[VladislavS]

С чашечкой кофе сел посмотреть доклад про концепты в С++20. Докладчик одновременно и скучный, и юморист, как бы это ни казалось странным. Сначала он отмочил:"Если бы программисты С++ боялись плохого синтаксиса, то они бы давно вымерли от страха."

А потом он вот этот код на слайде прокомментировал: "На самом деле вот тут понятно что написано" и зал дружно заржал

Код: Выделить всё

template<typename T> concept ImplicitlyDefaultConstructible
  = requires { [] (T) {} ({}); };

Какое красивое применения лямбды

[Eddy_Em]

В С настолько нечитабельный код только обфускатор может сделать!
Ещё одно доказательство того, что цепепе придумали для роботов!

[Reflector]

[uquote="Eddy_Em",url="/forum/viewtopic.php?p=3709177#p3709177"]Ещё одно доказательство того, что цепепе придумали для роботов![/uquote]
Как ты на С будешь делать подобные проверки? Была на другом форуме тема, TC захотел print() который будет сам определять тип переданных параметров, в итоге после долгих мучений родилась версия на обобщенных макросах:

Спойлер

Код: Выделить всё

#define dpr_(X) _Generic((X),           \
    const char*:        soft_print_con, \
    char*:              soft_print,     \
    uint8_t:            print_uint8,    \
    uint16_t:           print_uint16,   \
    uint32_t:           print_uint32,   \
    uint64_t:           print_uint64,   \
    int8_t:             print_int8,     \
    int16_t:            print_int16,    \
    int32_t:            print_int32,    \
    int64_t:            print_int64,    \
    float:              print_float,    \
    double:             print_double,   \
    default:            print_nex       \
)(X)

#ifndef CONCAT

#define CONCAT(a,b) a##b
#define CONCAT2(a,b) CONCAT(a,b)

#define ELEVENTH_ARGUMENT(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, ...) a11
#define COUNT_ARGS(...) ELEVENTH_ARGUMENT(_, ##__VA_ARGS__, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)

#define dpr_1(X) dpr_(X)
#define dpr_2(X,Y) do{dpr_(X); soft_print(" "); dpr_(Y);}while(0)
#define dpr_3(X,Y,Z) do{dpr_(X); soft_print(" "); dpr_(Y); soft_print(" "); dpr_(Z);}while(0)
#define dpr_4(X,Y,Z,W) do{dpr_(X); soft_print(" "); dpr_(Y); soft_print(" "); dpr_(Z); soft_print(" "); dpr_(W);}while(0)
#define dpr_5(X,Y,Z,W,E) do{dpr_(X); soft_print(" "); dpr_(Y); soft_print(" "); dpr_(Z); soft_print(" "); dpr_(W);soft_print(" ");dpr_(E);}while(0)
#define dpr_6(X,Y,Z,W,E,F) do{dpr_(X); soft_print(" "); dpr_(Y); soft_print(" "); dpr_(Z); soft_print(" "); dpr_(W);soft_print(" ");dpr_(E);soft_print(" ");dpr_(F);}while(0)
#define dpr_7(X,Y,Z,W,E,F,G) do{dpr_(X); soft_print(" "); dpr_(Y); soft_print(" "); dpr_(Z); soft_print(" "); dpr_(W);soft_print(" ");dpr_(E);soft_print(" ");dpr_(F);soft_print(" ");dpr_(G);}while(0)

#define dpr(...) CONCAT2(dpr_, COUNT_ARGS(__VA_ARGS__))(__VA_ARGS__)

#define printo(...) do{dpr(__VA_ARGS__);}while(0)

#endif

Количество параметров ограничено 7-ю, но конечно можно добавить еще больше еще более длинных макросов и это ограничение ослабить. А потом он добавил версию для С++ работающую с любым количеством параметров

Код: Выделить всё

template <typename T, typename ... Tail> void dpr(const T& obj, const Tail& ... tail) { dpr(obj); soft_print(' '); dpr(tail ...); }
template<typename ... T> void printo(const T& ... obj) { dpr(obj ...);  }

[ПростоНуб]

Reflector, я же писал выше, что параметрический полиморфизм на мономорфном ядре есть лишь синтаксический сахар. Очень спорно, перевешивают ли его достоинства его недостатки.
Праметрический полиморфизм без недостатков есть, например, в ML, но его обсуждение явно выходит за рамки темы.

[VladislavS]

Вот бы ещё без рекурсии развернуть вариадик.

Добавлено after 2 minutes 38 seconds:
[uquote="ПростоНуб",url="/forum/viewtopic.php?p=3709253#p3709253"]я же писал выше, что параметрический полиморфизм на мономорфном ядре есть лишь синтаксический сахар.[/uquote]Ну с этим IMHO не соглашусь.

[ПростоНуб]

VladislavS, Вы пропустили мой классический пример кривизны ad-hoc полиморфизма? Повторить?

И если Вы не считаете полиморфизм в C++ синтаксическим сахаром, то приведите пример алгоритма, который не реализуем без использования полиморфизма другими средствами языка.

[ARV]

неужели все достоинства С++ сводятся к легкой возможности реализации глупых фантазий?!
имхо, это не хорошо. до этого существовал естественный ограничитель безумства - дикая сложность реализации. теперь это барьер снят. и?
имхо, это не сделает мир программирования лучше.

[VladislavS]

[uquote="ПростоНуб",url="/forum/viewtopic.php?p=3709280#p3709280"]VladislavS, Вы пропустили мой классический пример кривизны ad-hoc полиморфизма? Повторить?[/uquote]С дуру и хрен сломать можно.
[uquote="ПростоНуб",url="/forum/viewtopic.php?p=3709280#p3709280"]И если Вы не считаете полиморфизм в C++ синтаксическим сахаром, то приведите пример алгоритма, который не реализуем без использования полиморфизма другими средствами языка.[/uquote]Списки типов.

[ПростоНуб]

VladislavS, при чем тут списки типов? Это алгоритм?
Вы вообще знаете, что такое синтаксический сахар?
Так вот и приведите пример алгоритма, которые не реализуем на C++ без использования полиморфизма.

Добавлено after 11 minutes 22 seconds:
VladislavS, с дуру можно все. Но когда конструкция языка повышает вероятность возникновения этого "с дуру", ее и называют спорной. Так снижение трудозатрат на написание кода, легко может перекрыться повышением трудозатрат при отладке и сопровождении кода. И я сам на это многократно нарывался.

Если Вы действительно считаете даже классический пример полиморфизма в С++ "дуростью", то что же можно сказать о боле сложных его применениях )))

[VladislavS]

[uquote="ПростоНуб",url="/forum/viewtopic.php?p=3709313#p3709313"]VladislavS, при чем тут списки типов? Это алгоритм?
Вы вообще знаете, что такое синтаксический сахар?
Так вот и приведите пример алгоритма, которые не реализуем на C++ без использования полиморфизма.[/uquote]Я, пожалуй, отвечу на все три вопроса одним кусочком кода. В нём и списки типов, и сложные алгоритмы, и полиморфизм, и синтаксический сахар. Инициализация всех ног контроллера разом.

Код: Выделить всё

ConfigList
< PinMode::PushPull_MediumSpeed<0>,               
    PA_3, PA_5, PA_7, PA_12, 
    GpioB<0x3F>, PB_13, PB_14, PB_15,
    GpioC<0xF>, PC_5, PC_6, PC_8, PC_9, PC_15,
  PinMode::Floating,               
    PA_0, PA_1, PA_2, PA_4, PA_6, PA_10, PA_11,
    PB_6, PB_12, PC_4, PC_7,
  PinMode::PullDown, 
    PA_13, PA_14,
  PinMode::AF_PushPull_MediumSpeed,               
    PA_8, PA_9, PA_15,
  PinMode::AF_OpenDrain_MediumSpeed, 
    PB_8, PB_9, PB_10, PB_11,
  PinMode::AF_PushPull_HighSpeed, 
    PB_7,
  PinMode::Floating, 
    CfgCmd::AllUnusedPins 
>::mode();

[uquote="ARV",url="/forum/viewtopic.php?p=3709286#p3709286"]имхо, это не сделает мир программирования лучше.[/uquote]Уже сделало, а будет ещё лучше.
Приложу ещё один кусочек кода. Класс, поддерживающий все микросхемы eeprom 24Сxx. Да, его было можно сделать и без шаблонов, и без constexpr, и без перегрузок функций. Но я как представлю это безудержный поток #ifdef-ов...

Спойлер

Код: Выделить всё

#pragma once

namespace EEPROM_AT24C
{
  
enum class EEType { AT24C01=0, AT24C02=1, AT24C04=2, AT24C08=3, AT24C16=4, 
                    AT24C32=5, AT24C64=6, AT24C128=7, AT24C256=8, AT24C512=9, AT24CM01=10, AT24CM02=11 };

struct EEParams
{
  uint32_t size;
  uint32_t page_size;
};

static constexpr EEParams AllParams[12] =  //Объём памяти и размер страницы для всех чипов 24Cxx
{ {128,8}, {256,8}, {512,16}, {1024*1,16}, {1024*2,16}, 
  {1024*4,38}, {1024*8,32}, {1024*16,64}, {1024*32,64}, {1024*65,128}, {1024*128,256}, {1024*256,256} };

template<typename TI2C, typename TDelay, EEType eeType, uint8_t HW_ADR>
class EE_24C
{
  public:    
    _inline_ constexpr EE_24C(){};
    
    static _inline_ bool ReadByte(uint16_t adr, uint8_t *data)
    {
      if constexpr (uint32_t(eeType)>=uint32_t(EEType::AT24CM01))
      { //Микросхемы с двухбайтовой адресацией  + биты в HW_ADR
        uint8_t new_adr = hw_adr + (((adr>>16)&0x3)<<1);
        return TI2C::ReadReg(new_adr,(uint16_t)adr, data, (uint8_t)1);
      }
      else if constexpr (uint32_t(eeType)>=uint32_t(EEType::AT24C32))        
      { //Микросхемы с двухбайтовой адресацией 
        return TI2C::ReadReg(hw_adr,(uint16_t)adr, data, (uint8_t)1);
      }
      else if constexpr(uint32_t(eeType)<=uint32_t(EEType::AT24C02))
      { //Микросхемы с однобайтовой адресацией  
        return TI2C::ReadReg(hw_adr,(uint8_t)adr, data, (uint8_t)1);
      }
      else
      { //Микросхемы с адресацией 1 байт + биты в HW_ADR
        uint8_t new_adr = hw_adr + (((adr>>8)&0x3)<<1);
        return TI2C::ReadReg(new_adr,(uint8_t)adr, data, (uint32_t)1);     
      }
    }
        
    static _inline_ bool WriteByte(uint16_t adr, uint8_t data)
    {
      if constexpr (uint32_t(eeType)>=uint32_t(EEType::AT24CM01))
      { //Микросхемы с двухбайтовой адресацией  + биты в HW_ADR
        uint8_t new_adr = hw_adr + (((adr>>16)&0x3)<<1);
        return TI2C::WriteReg(new_adr,(uint16_t)adr, &data, (uint8_t)1);
      }
      else if constexpr (uint32_t(eeType)>=uint32_t(EEType::AT24C32))
      { //Микросхемы с двухбайтовой адресацией  
        return TI2C::WriteReg(hw_adr,(uint16_t)adr, &data, (uint8_t)1); 
      }
      else if constexpr(uint32_t(eeType)<=uint32_t(EEType::AT24C02))
      { //Микросхемы с однобайтовой адресацией  
        return TI2C::WriteReg(hw_adr,(uint8_t)adr, &data, (uint8_t)1);
      }
      else
      { //Микросхемы с адресацией 1 байт + биты в HW_ADR
        uint8_t new_adr = hw_adr + (((adr>>8)&0x3)<<1);
        return TI2C::WriteReg(new_adr,(uint8_t)adr, &data, (uint8_t)1);      
      }      
    }
    
    static _inline_ bool ReadData(uint32_t adr, uint8_t *data, uint32_t length)
    {
      if constexpr (uint32_t(eeType)>=uint32_t(EEType::AT24CM01))
      { //Микросхемы с двухбайтовой адресацией  + биты в HW_ADR
        uint8_t new_adr = hw_adr + (((adr>>16)&0x3)<<1);
        return TI2C::ReadReg(new_adr,(uint16_t)adr, data, (uint32_t)length);
      }
      else if constexpr (uint32_t(eeType)>=uint32_t(EEType::AT24C32))        
      { //Микросхемы с двухбайтовой адресацией         
        return TI2C::ReadReg(hw_adr, (uint16_t)adr, data, (uint32_t)length);
      }
      else if constexpr(uint32_t(eeType)<=uint32_t(EEType::AT24C02))
      { //Микросхемы с однобайтовой адресацией  
        return TI2C::ReadReg(hw_adr,(uint8_t)adr, data, (uint8_t)length);
      }
      else
      { //Микросхемы с адресацией 1 байт + биты в HW_ADR
        uint8_t new_adr = hw_adr + (((adr>>8)&0x3)<<1);
        return TI2C::ReadReg(new_adr,(uint8_t)adr, data, (uint32_t)length);     
      }
    }
    
    static _inline_ bool WriteData(uint32_t adr, uint8_t *data, uint32_t length)
    {
      if( (((uint32_t)adr) + ((uint32_t)length)) > eeparams.size) return false; 
      uint32_t page_shift = adr&(eeparams.page_size-1);
      //Шаг 1: Запись начального кусочка
      uint32_t data2write = length<(eeparams.page_size-page_shift) ? length : (eeparams.page_size-page_shift);
      if(!WriteDataInOnePage(adr,data,data2write)) return false;   
      length -= data2write;
      adr+=data2write;
      data+=data2write;
      //Шаг 2: Запись остальных страниц (они уже выровнены)
      while(length)
      {
        TDelay::template Delay_ms<5>(); //Ждать пока предыдущая страница не запишется
        data2write = length<eeparams.page_size ? length : eeparams.page_size;
        if(!WriteDataInOnePage(adr,data,data2write)) return false;
        length -= data2write;
        adr+=data2write;
        data+=data2write;
      }
      return true;
    }
    
  private:    
    static constexpr uint8_t hw_adr=0xA0+((HW_ADR&0x7)<<1); 
    static constexpr EEParams eeparams  = AllParams[uint32_t(eeType)];
    
    static _inline_ bool WriteDataInOnePage(uint32_t adr, uint8_t *data, uint32_t length)
    {
      if constexpr (uint32_t(eeType)>=uint32_t(EEType::AT24CM01))
      { //Микросхемы с двухбайтовой адресацией  + биты в HW_ADR
        uint8_t new_adr = hw_adr + (((adr>>16)&0x3)<<1);
        return TI2C::WriteReg(new_adr,(uint16_t)adr, data, (uint32_t)length);
      }
      else if constexpr (uint32_t(eeType)>=uint32_t(EEType::AT24C32))
      { //Микросхемы с двухбайтовой адресацией  
        if constexpr(eeparams.page_size>255)
          return TI2C::WriteReg(hw_adr,(uint16_t)adr, data, (uint32_t)length);
        else
          return TI2C::WriteReg(hw_adr,(uint16_t)adr, data, (uint8_t)length); 
      }
      else if constexpr(uint32_t(eeType)<=uint32_t(EEType::AT24C02))
      { //Микросхемы с однобайтовой адресацией  
        return TI2C::WriteReg(hw_adr,(uint8_t)adr, data, (uint8_t)length);
      }
      else
      { //Микросхемы с адресацией 1 байт + биты в HW_ADR
        uint8_t new_adr = hw_adr + (((adr>>8)&0x3)<<1);
        return TI2C::WriteReg(new_adr,(uint8_t)adr, data, (uint8_t)length);      
      }
    }      
};

} // namespace EEPROM_AT24C

[ПростоНуб]

VladislavS, Вы утверждаете что тоже самое нельзя сделать без использования полиморфизма?

[VladislavS]

[uquote="ПростоНуб",url="/forum/viewtopic.php?p=3709330#p3709330"]VladislavS, Вы утверждаете что тоже самое нельзя сделать без использования полиморфизма? [/uquote]Как говорил Reflector, у вас сейчас обязательно найдётся неотложное дело и мы не увидим хотя бы близкой альтернативы.

[ПростоНуб]

ПростоНуб, А без демагонии? Вы утвердете, что проинициализировать пины МК без использования полиморфизма на C++ невозможно?

[VladislavS]

Демагогией занимаетесь как раз вы, а я конкретный пример привёл. Перекрыть который, я так понимаю, не чем?

[Reflector]

[uquote="ПростоНуб",url="/forum/viewtopic.php?p=3709253#p3709253"]я же писал выше, что параметрический полиморфизм на мономорфном ядре есть лишь синтаксический сахар. Очень спорно, перевешивают ли его достоинства его недостатки.
Праметрический полиморфизм без недостатков есть, например, в ML, но его обсуждение явно выходит за рамки темы.[/uquote]
Недостатки есть везде, но если брать более современные языки родственные С, то там почти везде есть дженерики. В С++ есть шаблоны и это активно развивающееся направление языка, что явно указывает на его полезность, дженерики в разных реализациях есть в C#, Java, D, Rust, причем в части языков необходимость их добавления осознали на сразу. В Gо пока ничего такого нет и это была ошибка, насколько знаю добавление обобщенного программирования в Go уже запланированно вместе с контрактами... А если что-то забраковывать на основании имеющихся недостатков, то вообще языков программирования не останется

Вы вообще знаете, что такое синтаксический сахар?
Так вот и приведите пример алгоритма, которые не реализуем на C++ без использования полиморфизма.

Зачем мелочиться, можно из языка выкинуть почти все, главное чтобы он остался полным по Тьюрингу, и все выкинутое будет синтаксическим сахаром

[ПростоНуб]

VladislavS, демагогия, это когда на прямой вопрос вместо "да" или "нет", отвечают что угодно, лишь бы на вопрос не ответить. Так да или нет?

Добавлено after 6 minutes 34 seconds:
Reflector, прошу прощения, но я называю ad-hoc полиморфизм спорным преимуществом, а не ненужным.
Почему Вы не ответили на мой прямой вопрос к Вам в классическом примере полиморфизма в C++? Так что будет сравнивать полиморфный шаблон? Указатели или то, на что они указывают? А если речь будет уже о сложных объектах, с тысячами срок кода их реализации?

Добавлено after 9 minutes 58 seconds:
[uquote="Reflector",url="/forum/viewtopic.php?p=3709342#p3709342"]можно из языка выкинуть почти все, главное чтобы он остался полным по Тьюрингу, и все выкинутое будет синтаксическим сахаром[/uquote]
Вы совершенно правы. По определению синтаксического сахара - это именно так!
Другое дело, что, например, ситаксический сахар в виде оператора for лишен недостатков, а синтаксический сахар в виде ad-hoc полиморфизма такими недостатками обладает.

[Reflector]

[uquote="ПростоНуб",url="/forum/viewtopic.php?p=3709344#p3709344"]Почему Вы не ответили на мой прямой вопрос к Вам в классическом примере полиморфизма в C++? Так что будет сравнивать полиморфный шаблон? Указатели или то, на что они указывают? А если речь будет уже о сложных объектах, с тысячами срок кода их реализации?[/uquote]
Функция сравнивает то, что ей передают, если это сишные строки передаваемые как указатели, то программист должен понимать какой будет результат, тем более в описании написано, что для сравнения используется оператор '<'. Если он не понимает, то и без всяких шаблонов может на С написать практически то же самое:

Код: Выделить всё

char *s = ("last" > "first") ? "last" : "first";

И что С теперь плохой, все дружно перебираемся на паскаль?

ps. Лично у меня max() совершенно не ассоциируется с функцией сравнивающей строки...