Почему в c++ еще нету Null-Conditional Operator?

Adamos, так ?? применяют чтобы обработать null, а вы наоборот... или я что-то не пойму...

Почему в c++ еще нету Null-Conditional Operator?

Adamos, Можно же указать бы ?? (null-coalescing operator) - это как раз else.

Можно ли не указывать полный путь до ресурса в другом проекте?

Не понял как второй пункт делается

Почему не запускается WebAssembly PWA страница?

А например нельзя использовать http.server на python?

Откута берется эта белая линия?

VoidVolker, ты под квадратами имеешь в виду пиксели? как это реализовать интересно?

Откута берется эта белая линия?

VoidVolker, не вижу квадратов

Откута берется эта белая линия?

не понял как это исправить

Можно ли сделать концепт для функции у которой return value auto?

Acaunt, надо было в ответ написать

Можно ли сделать концепт для функции у которой return value auto?

Acaunt, я где-то писал что это тип?

Можно ли узнать типы сигнатуры std::function?

Евгений Шатунов, Если что события я делаю чисто под себя, а не для библиотеки и поэтому оставлю std::function для удобства. В любом случае спасибо за уделенное время!

Можно ли узнать типы сигнатуры std::function?

Евгений Шатунов, Ну а как хранить тогда callable объект? Я хочу чтобы событию я передал делегат т.е класс который хранит ссылку на callable объект. Можно конечно передать сигнатуру функции, но я хочу именно делегат. Можно конечно сделать еще одну специализацию.

Можно ли узнать типы сигнатуры std::function?

Евгений Шатунов,

template<typename TObject, typename TEventArgs>
class Event<std::function<void(TObject*, const TEventArgs& e)>>

Так? Как-то не особо вникал в частичную специализацию. Всегда думал что у нее шаблон всегда пустой.

Можно ли узнать типы сигнатуры std::function?

Евгений Шатунов, Пытался улучшить как мог:

EventHandler

template<typename TObject, typename TEventArgs> 
	requires std::derived_from<TEventArgs, EventArgs>
class EventHandler: public std::function<void(TObject*, const TEventArgs&)>
{
public:
	using Base = std::function<void(TObject*, const TEventArgs&)>;
	using Object = TObject;
	using EventArgs = TEventArgs;
public:
	EventHandler() = default;

	template<typename TCallable> 
		requires !std::is_same_v<std::decay_t<TCallable>, EventHandler>
	EventHandler(TCallable&& handler):
		Base(std::forward<TCallable>(handler))
	{}

	EventHandler(const EventHandler& handler):
		Base(static_cast<const Base&>(handler))
	{}

	EventHandler(EventHandler&& handler) noexcept:
		Base(static_cast<Base&&>(handler))
	{}

	template<typename TCallable> 
		requires !std::is_same_v<std::decay_t<TCallable>, EventHandler>
	EventHandler& operator=(TCallable&& handler)
	{
		Base::operator=(std::forward<TCallable>(handler));
		return *this;
	}

	EventHandler& operator=(const EventHandler& handler)
	{
		Base::operator=(static_cast<const Base&>(handler));
		return *this;
	}

	EventHandler& operator=(EventHandler&& handler) noexcept
	{
		Base::operator=(static_cast<Base&&>(handler));
		return *this;
	}

	bool operator==(const EventHandler& eventHandler) const noexcept
	{
		return this->target_type() == eventHandler.target_type();
	}

	bool operator!=(const EventHandler& eventHandler) const noexcept
	{
		return !operator==(eventHandler);
	}
};

Event

template<typename TEventHandler, 
		 typename TObject = typename TEventHandler::Object,
		 typename TEventArgs = typename TEventHandler::EventArgs> requires
	std::is_base_of_v<EventHandler<typename TEventHandler::Object,
								   typename TEventHandler::EventArgs>, TEventHandler>
class Event
{
public:
	using EventHanlder = TEventHandler;
protected:
	std::forward_list<TEventHandler> _handlers;
public:
	void Clear() noexcept { _handlers.clear(); }

	template<typename TCallable> 
		requires !std::is_same_v<std::decay_t<TCallable>, TEventHandler>
	void operator+=(TCallable&& callable)
	{
		_handlers.emplace_front(std::forward<TCallable>(callable));
	}

	void operator+=(TEventHandler&& handler)
	{
		_handlers.push_front(std::move(handler));
	}

	void operator+=(const TEventHandler& handler)
	{
		_handlers.push_front(handler);
	}

	template<typename TCallable> 
		requires !std::is_same_v<std::decay_t<TCallable>, TEventHandler>
	void operator-=(TCallable&& callable)
	{
		_handlers.remove(std::forward<TCallable>(callable));
	}

	void operator-=(TEventHandler&& handler)
	{
		_handlers.remove(std::move(handler));
	}

	void operator-=(const TEventHandler& handler)
	{
		_handlers.remove(handler);
	}

	operator bool() const noexcept { return !_handlers.empty(); }

	void operator()(TObject* sender, const TEventArgs& e) const
	{
		for(const TEventHandler& handler : _handlers)
		{
			handler(sender, e);
		}
	}
};

Все же хочу оставить как шаблон. Если использовать не шаблон, то в качестве делегатов должны быть только нужные классы, т.е уже лямбы отпадают, мне такое не подходит. Сделал так чтобы в качестве аргумента для Event был только EventHandler.

Можно ли узнать типы сигнатуры std::function?

Евгений Шатунов, Вот -

Event

template<typename THandler>
class Event
{
protected:
	std::forward_list<THandler> _handlers;
public:
	void operator+=(auto&& handler) 
	{ 
		_handlers.emplace_front(std::forward<decltype(handler)>(handler));
	}

	void operator-=(auto&& handler) 
	{ 
		_handlers.remove(std::forward<decltype(handler)>(handler));
	}

	operator bool() const noexcept
	{ 
		return !_handlers.empty();
	}

	template<typename TObject, typename TEventArgs> requires std::derived_from<TEventArgs, EventArgs>
	void operator()(TObject* sender, const TEventArgs& e) const
	{
		for(const THandler& handler : _handlers)
		{
			handler(sender, e);
		}
	}

	void Clear() noexcept
	{ 
		_handlers.clear(); 
	}
};

Знать конечно не обязательно, можно всегда посмотреть, но хотелось бы если это возможно когда я начинаю писать оператор, и мне высвечивались конкретные типы для данного обработчика. Чтобы бы я не искал как там называется EventArgs для разных событий. Конечно это не критично. Но тут вопрос возможно ли узнать их.
UPD:
В общем разобрался как. Сделал отдельный класс:

template<typename TObject, typename TEventArgs> requires std::derived_from<TEventArgs, EventArgs>
class EventHandler: public std::function<void(TObject*, const TEventArgs&)>
{
public:
	using ObjectType = TObject;
	using ArgsType = TEventArgs;
};

и теперь в Event так:

void operator()(THandler::ObjectType* sender, const THandler::ArgsType& e) const
{
	for(const THandler& handler : _handlers)
	{
		handler(sender, e);
	}
}

Можно ли узнать типы сигнатуры std::function?

Через шаблон.

Можно ли узнать типы сигнатуры std::function?

Евгений Шатунов, Хотелось бы видить конкретные для данного события типы аргументов которые требуются передать. В данный момент я вызываю через шаблон.

template<typename TObject, typename TEventArgs> requires std::derived_from<TEventArgs, EventArgs>
void operator()(TObject* sender, const TEventArgs& e) const
{
	for(const THandler& handler : _handlers)
	{
		handler(sender, e);
	}
}

Почему может падать качество преобразования АЦП при повышении частоты сигнала?

jcmvbkbc, Нет я дискретизирую на частоте в 4 раза больше, т.е если 100 Гц то будет 400 Гц. Но проблема была в другом. Получается генератор частот получается идеальный(тестрирую в программе) то и наложений более высоких частот нет, но была проблема с ОУ которые сдвигали сигнал и после него там на фротах были проседания.

Почему может падать качество преобразования АЦП при повышении частоты сигнала?

По той же логике и в 100 Гц будут присутсвовать составляющие высоких частот и они же не зависимы от часоты всегда будут там? то почему то при 100 Гц все в пределах 0,5%

Почему может не заходить в обработчик таймер [STM32]?

AiR_WiZArD, Ну т.е второй способо это как вы предложили но еще настроить также таймер 3 на 125 мкс? и вызвывать один раз в main и соответсвенно обратывать после того как буфер будет заполнен в HAL_ADC_ConvCpltCallback. Или не так?

int main()
{
    // some code
    HAL_TIM_Base_Start(&htim3);
    HAL_ADC_Start_DMA(&hadc1, &adcValue, DMABufferSize);
    while(1)
    {
        // some code
    }
}

А в настройках DMA не надо менять request mode на circular?

Почему может не заходить в обработчик таймер [STM32]?

AiR_WiZArD, Если я частоту повышу в 2(3) раза, то смогу считывать 125 мкс с HAL_TIM_PeriodElapsedCallback или все еще нет?