Приведение к void* и обратно к Original_Data_Type*

Интересно, есть ли какие-либо подводные камни/проблемы при этом?

Вы должны быть абсолютно уверены, возвращая void* обратно к определенному типу, иначе вы получите неопределенное поведение и потенциальную катастрофу. Как только вы используете void *, вы теряете безопасность типов. Трудно отследить, на какой тип на самом деле указывает void *, нет способа гарантировать или определить, что это действительно так. указывает на тип, к которому вы собираетесь привести его обратно.

Можно ли каким-либо образом столкнуться с ошибкой или неопределенным условием при приведении к void* и обратно?

Да, сценарий, упомянутый в #1.

Как мы должны решать такие проблемы, если они есть?

Избегайте полного использования void * в C++, вместо этого используйте шаблоны и наследование.
В C он может вам абсолютно понадобиться в определенных ситуациях, но постарайтесь свести его использование к минимуму.
Итог:
C/C++ позволяет вам стреляй себе в ногу, тебе решать делать или не делать.

Это совершенно справедливо. Вот что стандарт говорит об этом:

§4.10 Преобразование указателя

2 Значение r типа «указатель на cv T», где T — тип объекта, может быть преобразовано в значение r типа «указатель на cv void». Результат преобразования «указателя на cv T» в «указатель на cv void» указывает на начало места хранения, где находится объект типа T, как если объект является наиболее производным объектом (1.8) типа T (то есть не является подобъектом базового класса).

что означает, что вы можете преобразовать указатель на класс в указатель void. А также ...

§5.2.9 Статическое приведение

10 Rvalue типа "указатель на cv void" может быть явно преобразовано в указатель на объектный тип. Значение типа указатель на объект, преобразованное в «указатель на cv void» и обратно в исходный тип указателя, будет иметь исходное значение.

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

Надеюсь, поможет. Удачи!

В C++ вам не нужно статическое приведение, чтобы добраться до to void*:

int main()
{
    CFoo* foo = new CFoo;
    void* dt = foo;
    tfunc(dt); // or tfunc(foo);

    return 0;
}

NB: ваша реализация tfunc() вполне правильная в том смысле, что она действительно нуждается в приведении.

Я нечасто видел приведение к void* в C++. Это практика в C, которой активно избегают в C++.

Приведение к void* удаляет все типы безопасности.

Если вы используете reinterpret_cast или static_cast для приведения типа указателя к void* и обратно к тому же типу указателя, стандарт гарантирует, что результат будет четко определенным.

Опасность заключается в том, что вы можете привести void* к неправильному типу, так как вы больше не уверены в правильности типа.

Единственное, что предоставляет стандарт, это то, что с учетом A* pa, (A*)(void*)pA == pA. следствие

void* pv = pA;
A* pA2 = (A*)pv;
pA2->anything ...

будет таким же, как pA->anything ...

Все остальное «не определено», объявление, по сути, так или иначе зависит от реализации.

Основываясь на своем опыте, вот некоторые известные подводные камни:

• Считайте, что A производная форма B, pA и pB будет A* и B*. pB=pA заставляет pB указывать на основание A. Это не означает, что pB и pA — это один и тот же адрес. следовательно, pB = (B*)(void*)pA на самом деле может указывать где угодно еще на A (хотя объекты одиночного наследования обычно реализуются с использованием одного и того же источника, поэтому, по-видимому, он работает нормально)
• То же самое и наоборот: если предположить, что pB на самом деле указывает на A, pA = (A*)(void*)pB не обязательно правильно указывает на объект A. Правильный путь pA = static_cast<A*>(pB);
• Если вышеуказанные пункты могут работать с большинством реализаций одиночного наследования, они никогда не будут работать с множественным наследованием для баз, отличных от первого: рассмотрим class A: public Z, public B { ... };, если Z не пусто, учитывая A, подкомпонент B не будет иметь тот же адрес A. (и множественное наследование в С++ везде, где есть iostream)
• Иногда все зависит и от платформы: (char*)(void*)pI (где pI указывает на целое число) не будет таким же, как "*pI, если *pI в (-128..+127)" (это будет только на машинах с прямым порядком байтов)

В целом не думайте, что преобразование между типами работает, просто изменяя способ интерпретации адреса.

Я знаю много функций в драйвере и т. д., использующих указатели void для возврата данных вызывающей стороне, схема в основном такая же:

int requestSomeData(int kindOfData, void * buffer, int bufferSize);

Эта функция может принимать различные типы данных в качестве параметра. Что они делают, так это используют bufferSize в качестве параметра, чтобы избежать записи в места памяти, в которые они не должны писать. Если bufferSize не соответствует или меньше, чем данные, которые должны быть возвращены, функция вместо этого вернет код ошибки.

В любом случае: избегайте их использования или трижды подумайте, прежде чем писать какой-либо код.

Это действительно?

Да, это действительно согласно стандарту § 5.2.9.7.

Значение prvalue типа «указатель на cv1 void» может быть преобразовано в значение prvalue типа «указатель на cv2 T», где T — тип объекта, а cv2 — такое же или большее значение cv-квалификации, чем cv1. Значение нулевого указателя преобразуется в значение нулевого указателя целевого типа. Значение типа указатель на объект, преобразованное в «указатель на cv void» и обратно, возможно, с другой квалификацией cv, должно иметь исходное значение. [Пример:

T* p1 = new T;
const T* p2 = static_cast<const T*>(static_cast<void*>(p1));
bool b = p1 == p2; // b will have the value true.