Russian Qt Forum

for (auto it = std::begin(container); it != std::end(container); ++it)

template<typename T>
void iterateContainer(const T& t)
{
    for (auto it = std::begin(t); it != std::end(t); ++it)
    {
        // do something
    }
}

void testIterate()
{
    std::vector<int> vec;
    std::list<int> list;
    std::map<int, std::string> map;
    iterateContainer(vec);
    iterateContainer(list);
    iterateContainer(map);
}

void foo(Type &t) {...}
void foo(Type *t) {foo(*t); }

struct CBigClass {
...
 QList<CData> mData;
 QSet<std::reference_wrapper<CData>> mSelection; 
...
};

struct CBigClass {
...
	QSet<std::reference_wrapper<CData>>& mSelectionAsRefs() 
	{
		static_assert(sizeof(CData*) == sizeof(std::reference_wrapper<CData>));
		return reinterpret_cast<QSet<std::reference_wrapper<CData>>&>(mSelection);
	}
};

static_assert(sizeof(CData*) == sizeof(std::reference_wrapper<CData>));

vector<bool> bools;
auto &chars = reinterpret_cast<vector<char>&>(bools);

vector<bool> bools;
auto &chars = reinterpret_cast<vector<char>&>(bools);

#include <iostream>

int foo(float* f, int* i)
{
	*i = -1;
	*f = 0.0f;

	return *i;
}

int main(int, char *[])
{
	int i;
	//i = foo(reinterpret_cast<float*>(&i), &i);  // 1
	i = foo(new(&i) float, &i);                   // 2
	std::cout << i << std::endl;
}

#include <iostream>

#if 0  // 0 - OK, 1 - UB
typedef float F;
#else
struct F
{
	int i;
	F(float v = 0.0f) { reinterpret_cast<float&>(i) = v; }
};
#endif

int foo(F* f, int* i)
{
	*i = -1;
	*f = 0.0f;

	return *i;
}

int main(int, char *[])
{
	int i;
	//i = foo(reinterpret_cast<F*>(&i), &i);  // 1
	i = foo(new(&i) F(), &i);                   // 2
	std::cout << i << std::endl;
}

void foo(std::shared_ptr<MyClass> c, int x);

foo(std::shared_ptr<MyClass>(new MyClass), getXValue());

foo(f(), g());

void doWork(const CData &data)
{
}

template<typename С>
void iterateContainer(const С& c)
{
    for (const auto &item: c)
    {
        if constexpr (std::is_pointer_v<C::value_type>)
            doWork(*item);
        else
            doWork(item);
    }
}

struct CBigClass {
...
 QList<CData*> mData;
 QSet<CData *> mSelection; 
...
}

или

struct CBigClass {
...
 QList<CData> mData;
 QSet<reference_wrapper<CData>> mSelection; 
...
};

void CBigClass::SomeMethod( bool useSelection ) 
{
  ..
  CDataIt it(*this, useSelection);
  while (it.HasNext()) {
    CData & data = it.GetNext();
    ....
}

QSet<std::reference_wrapper<CData>>& mSelectionAsRefs() 
{
	static_assert(sizeof(CData*) == sizeof(std::reference_wrapper<CData>));
	return reinterpret_cast<QSet<std::reference_wrapper<CData>>&>(mSelection);
}

QSet<std::reference_wrapper<CData>>& mSelectionAsRefs()
{
	static_assert(sizeof(CData*) == sizeof(std::reference_wrapper<CData>));

	QSet<CData*>* src = &mSelection;
	QSet<std::reference_wrapper<CData>>* alias;
		
	std::memcpy(&alias, &src, sizeof(alias));  // starts lifetime of alias as QSet<CData*>*
	return *alias;
}

QSet<std::reference_wrapper<CData>>& mSelectionAsRefs()
{
	static_assert(sizeof(CData*) == sizeof(std::reference_wrapper<CData>));

	QSet<CData*>* src = &mSelection;
	void* alias;

	std::memcpy(&alias, &src, sizeof(alias));  // starts lifetime of alias as QSet<CData*>*
	return *static_cast<QSet<std::reference_wrapper<CData>>*>(alias);
}

QSet<std::reference_wrapper<CData>>& mSelectionAsRefs() 
{
	static_assert(sizeof(CData*) == sizeof(std::reference_wrapper<CData>));
	return std::bit_cast<QSet<std::reference_wrapper<CData>>&>(mSelection);
}

void* p;          // declaration
p = new int(5);   // p begins its lifetime with dynamic type int*

int i;
void* p;  // declaration
p = &i;  // p begins its lifetime with dynamic type int*

#include <QSet>
#include <iostream>

using namespace std;

typedef int CData;
using CDataRef = reference_wrapper<CData>;

QSet<CData*>* mSelection = new QSet<CData*>;

QSet<CDataRef>*& SelectionAsRefs( void )
{
	static_assert(sizeof(CData*) == sizeof(CDataRef));
	return *(QSet<CDataRef> **) &mSelection;
}

static QSet<CData*>* makeUB(QSet<CData*>** src, QSet<CDataRef>** alias)
{
	static QSet<CData*> data = { new CData };  // set with one element

	*src = &data;
	*alias = nullptr;

	return *src;  // what will be there: &data or nullptr?
}

int main(int, char *[])
{
	mSelection = makeUB(&mSelection, &SelectionAsRefs());
	std::cout << (!mSelection ? "OK" : "UB") << std::endl;
}