I'm curious about the size of a very simple Demo object , so , I'm writing the following code
#include <windows.h>
#include "winrt/base.h"
#include <iostream>
#pragma comment(lib, "windowsapp")
/*
cl /nologo /await /std:c++latest /wd4002 /EHsc base_so.cpp
*/
using namespace std;
using namespace winrt;
using namespace winrt::impl;
struct IDemo;
template <typename D>
struct consume_IDemo
{
void hello();
};
template <> struct consume<IDemo> { template <typename D> using type = consume_IDemo<D>; };
template <typename D> void consume_IDemo<D>::hello()
{
WINRT_SHIM(D)->hello();
}
struct WINRT_EBO __declspec(uuid("3A44B7CC-9CB6-4512-8CAD-6400E662D865"))
IDemo : Windows::Foundation::IInspectable, consume_t<IDemo>
{
IDemo(std::nullptr_t = nullptr) noexcept {};
};
template <> struct abi<IDemo>
{
struct type : IInspectable
{
virtual HRESULT hello() = 0;
};
};
template <typename D>
struct produce<D,IDemo> : produce_base<D,IDemo>
{
HRESULT hello() override
{
shim().hello();
return S_OK;
}
};
struct Demo : implements<Demo,IDemo>
{
Demo()
{
cout << "sizeof Demo 0x" << hex << sizeof(*this) << dec << endl;
cout << "sizeof m_references 0x" << hex << sizeof(std::atomic<std::conditional_t<1, uintptr_t, uint32_t>>) << dec << endl;
cout << "is_composing " << is_composing << endl;
cout << "outer " << outer() << endl;
}
HRESULT hello()
{
cout << __FUNCTION__ << endl;
return S_OK;
}
};
int main()
{
Demo d;
}
and the output is
sizeof Demo 0x18
sizeof m_references 0x8
is_composing 0
outer 0000000000000000
I think the sizeof Demo should be 0x10 (64 machine) : sizeof(m_references)+sizeof(produce<Demo,IDemo>) , so , what is the extra 8 bytes ? many thanks!
It's either padding or v-tables. Maybe both...
The compiler is likely to insert a v-table pointer for each base class that has at least one virtual method declared. (And as an aside, when you do a C-cast, static_cast, or dynamic_cast from the concrete class to the non-first base class, the compiler will change the pointer value to that of the base-class or its v-table.)
Let's break it down.
Demo inherits from implements<Demo,IDemo>
implements is defined as follows:
struct implements : impl::producers<D, I...>, impl::base_implements<D, I...>::type
{
Now we're getting into WinRT noise. But it does seem to suggest multiple-inheritance. But it's just easier to break this out it the debugger.... There you go. The first vtable is for IUnknown. The other is something related to IInspectable.
So it makes sense. Each v-table is an 8 byte pointer. And the m_references is also 8 bytes. 8+8+8 = 24 = 0x18
Related
Consider this snippet:
struct A {
template <typename T> void bar(const T &) {
/*
I would like to write something like:
if constexpr(type T already processed/T is already present in typelist)
...do something fancy
else if constexpr(type T not processed/T is not present in typelist)
*/
}
};
struct Msg1 {};
struct Msg2 {};
int main() {
A a;
a.bar(Msg1{});
a.bar(Msg1{});
}
Demo
Is it possible to see at compile time for which types the method bar was already instantiated?
Ideally, there would be some kind of growing typelist, where one can check at compile time for which types bar is already instantiated.
No. It is not possible to do so at compile time. However, it would be possible to do the following at runtime:
#include <typeindex>
#include <type_traits>
#include <unordered_set>
struct A {
private:
std::unordered_set<std::type_index> already_processed_ts;
public:
template<typename T>
void bar(const T&){
if(already_processed_ts.find(typeid(T)) != already_processed_ts.end())
std::cout << "Already processed " << typeid(T).name() << std::endl;
else{
already_processed_ts.insert(typeid(T));
std::cout << "Processing " << typeid(T).name() << "... \n";
}
}
}
struct Msg{};
int main()
{
f(Msg{}); // Prints "Processing 3Msg..." (at least on my compiler)
f(Msg{}); // Prints "Already processed 3Msg"
return 0;
}
I made an empty class having specific offset and want to derived class using that area..
like below code.. I use alignas()
#include <iostream>
#include <string>
#include <string.h>
using namespace std;
#pragma pack (push, 1)
class alignas(32) base
{
public:
base() { init(); }
void init() { memset(this, 0, 32); }
}; // sizeof(base) = 32
class derived01 : public base
{
int a;
int b;
}; // sizeof(derived01) = 32
class derived02 : public base
{
char a[20];
}; // sizeof(derived02) = 32
class item
{
int a;
base b;
int c;
public:
template <typename T>
inline T GetDerived()
{
return reinterpret_cast<T>(&b);
}
};
#pragma pack (pop)
int main()
{
cout << "ItemUnit :" << sizeof(base) << endl;
cout << "derived01 :" << sizeof(derived01) << endl;
cout << "derived02 :" << sizeof(derived02) << endl;
cout << "item :" << sizeof(item) << endl;
// I want to get Derived Class like this..
//item* i = new item();
//derived02 d = i.GetDerived<derived02>();
return 0;
}
and, it seemed to work as expected.. In LINUX.. (g++ 7.4)
# ./a
ItemUnit :32
derived01 :32
derived02 :32
item :40
but in MSVS2019, it returned..
ItemUnit :32
derived01 :32
derived02 :32
item :96
I also thought about other ways, but they have some....
UNION but, it cant using inheritance.. and I think it inconvenient to use.
make base class having char[32].. and derived having only functions to get,set using offset..
Is there any other good way?
please advice..
The classic 32-bit Borland/Embarcadero compiler - a.k.a. bcc32 - exhibits a strange failure when a traits class is specialised for std::vector<bool>. In particular, it fails to compile usages of the specialisation because it doesn't find any of its members. With other types - like std::vector<char> - there is no problem at all. Tested with BC++ 5.5.1 (free) and BC++ 7.1 (RX/Seattle).
Is there a workaround for this?
#include <iostream>
#include <typeinfo>
#include <vector>
template<typename T>
struct traits { };
template<> struct traits< std::vector<char> >
{
enum { ENUM = 42 };
static int func () { return ENUM; }
};
template<> struct traits< std::vector<bool> >
{
enum { ENUM = 666 };
static int func () { return ENUM; }
};
///////////////////////////////////////////////////////////////////////////////////////////////////
template<typename T>
void test ()
{
typedef traits<T> TT;
// separate lines to see exactly where the compiler barfs
std::cout << typeid(T).name();
std::cout << " " << TT::ENUM; // E2451 Undefined symbol 'ENUM'
std::cout << " " << TT::func(); // E2451 Undefined symbol 'func'
TT tt;
std::cout << " " << tt.ENUM; // E2316 'ENUM' is not a member of 'traits<std::_Bvector>'
std::cout << " " << tt.func(); // E2316 'func' is not a member of 'traits<std::_Bvector>'
std::cout << "\n";
}
int main ()
{
test< std::vector<char> >();
test< std::vector<bool> >();
return 0;
}
Note: a somewhat hackish workaround that can be useful in certain circumstances is to code the specialisation for vector<bool> into the primary template (which would normally be left undefined); the specialisations on other types can then be done as usual, and the code works as expected even with bcc32.
A runtime assert can verify that the only unspecialised incarnation of the traits template is the one for std::vector<bool>. Templates that use the traits would then invoke the assertion code in a convenient place (which could also be a static function).
template<typename T>
struct traits
{
// specialisation for std::vector<bool> coded here...
enum { ENUM = 666 };
static int func () { return ENUM; }
static void assert_only_vector_bool_not_specialised ()
{
assert(typeid(T) == typeid(std::vector<bool>));
}
};
struct traits_specialisation_base
{
static void assert_only_vector_bool_not_specialised ()
{
}
};
template<> struct traits< std::vector<char> >: traits_specialisation_base
{
enum { ENUM = 42 };
static int func () { return ENUM; }
};
// ...
template<typename T>
struct UsingTraits
{
typedef traits<T> TT;
UsingTraits ()
{
TT::assert_only_vector_bool_not_specialised();
}
};
// ...
UsingTraits< std::vector<char> > erna;
UsingTraits< std::vector<bool> > fred;
There is something fishy in the std:: with std::vector<bool> so you need to use the std:: type instead. just change to:
#include <iostream>
#include <typeinfo>
#include <vector>
//---------------------------------------------------------------------------
template<typename T> struct traits
{
// this is safe constructor/destructor for Borland BDS2006 and later
traits(){};
traits(traits& a){};
~traits(){};
traits* operator = (const traits *a){};
//traits* operator = (const traits &a){}; // use this only if you have dynamic allocation members
};
template<> struct traits< std::vector<char> >
{
enum { ENUM = 42 };
static int func () { return ENUM; }
};
template<> struct traits< std::_Bvector > // here use the std type directly
{
enum { ENUM = 666 };
static int func () { return ENUM; }
};
//---------------------------------------------------------------------------
template<typename T> void test ()
{
typedef traits<T> TT;
// separate lines to see exactly where the compiler barfs
std::cout << typeid(T).name();
std::cout << " " << TT::ENUM; // E2451 Undefined symbol 'ENUM'
std::cout << " " << TT::func(); // E2451 Undefined symbol 'func'
TT tt;
std::cout << " " << tt.ENUM; // E2316 'ENUM' is not a member of 'traits<std::_Bvector>'
std::cout << " " << tt.func(); // E2316 'func' is not a member of 'traits<std::_Bvector>'
std::cout << "\n";
// can ignore this ... it is just output to memo I do not use console
AnsiString s="";
s=s+typeid(T).name() + "\n";
s=s+" " + AnsiString( TT::ENUM ) + "\r\n"; // E2451 Undefined symbol 'ENUM'
s=s+" " + AnsiString( TT::func() ) + "\r\n"; // E2451 Undefined symbol 'func'
s=s+" " + AnsiString( tt.ENUM ) + "\r\n"; // E2316 'ENUM' is not a member of 'traits<std::_Bvector>'
s=s+" " + AnsiString( tt.func() ) + "\r\n"; // E2316 'func' is not a member of 'traits<std::_Bvector>'
Form1->mm_log->Lines->Add(s);
}
//---------------------------------------------------------------------------
// this is your main()
__fastcall TForm1::TForm1(TComponent* Owner):TForm(Owner)
{
test< std::vector<char> >();
test< std::vector<bool> >();
}
//---------------------------------------------------------------------------
I use windows form app so ignore form stuff. The constructors/destructors are not necessary for compilation but you should add them because of the Borland BDS2006 and latter C++ engine bug. For more info see:
BDS 2006 C hidden memory manager conflicts
Too many initializers error for a simple array in bcc32
The code above gives me this output:
std::vector<char,std::allocator<char> >
42
42
42
42
std::vector<std::allocator<bool> >
666
666
666
666
So I have my own policy for uint64_t to uint32_t numeric cast
struct MyOverflowHandlerPolicy
{
void operator() ( boost::numeric::range_check_result ) {
std::cout << "MyOverflowHandlerPolicy called" << std::endl;
throw boost::numeric::positive_overflow();
};
} ;
How do I get it to be used by boost::numeric_cast?
In order to use numeric_cast, numeric_cast_traits specialization should defined on each type conversions. These specializations are already defined with default values for the built-in numeric types. It is possible to disable the generation of specializations for built-in types by defining BOOST_NUMERIC_CONVERSION_RELAX_BUILT_IN_CAST_TRAITS (details).
Here is a small running sample.
#include <iostream>
#include <stdexcept>
#define BOOST_NUMERIC_CONVERSION_RELAX_BUILT_IN_CAST_TRAITS
#include <boost/numeric/conversion/cast.hpp>
using namespace std;
struct YourOverflowHandlerPolicy
{
void operator() ( boost::numeric::range_check_result r ) {
cout << "YourOverflowHandlerPolicy called" << endl;
if (r != boost::numeric::cInRange) {
throw logic_error("Not in range!");
}
};
};
namespace boost { namespace numeric {
template <>
struct numeric_cast_traits<uint32_t, uint64_t>
{
typedef YourOverflowHandlerPolicy overflow_policy;
typedef UseInternalRangeChecker range_checking_policy;
typedef Trunc<uint64_t> rounding_policy;
};
template <>
struct numeric_cast_traits<uint64_t, uint32_t>
{
typedef YourOverflowHandlerPolicy overflow_policy;
typedef UseInternalRangeChecker range_checking_policy;
typedef Trunc<uint32_t> rounding_policy;
};
}} //namespace boost::numeric;
int main()
{
try {
cout << boost::numeric_cast<uint32_t>((uint64_t)1) << endl; // OK
cout << boost::numeric_cast<uint32_t>((uint64_t)1<<31) << endl; // OK
cout << boost::numeric_cast<uint32_t>((uint64_t)1<<32) << endl; // Exception
} catch (...) {
cout << "exception" << endl;
}
return 0;
}
Output:
YourOverflowHandlerPolicy called
1
YourOverflowHandlerPolicy called
2147483648
YourOverflowHandlerPolicy called
exception
Note: I have boost release 1.55.0, I don't know the minimum release level to get it compiled but it isn't compiled with 1.46.0. So, please check your boost release and update if necessary.
I'm trying to do separate compilation of my non-type argument template, but I am facing a few problems. My application has a number of opcodes, and each opcode is associated with certain data and functions, many of which are similar and could be defined in the primary template, then the differences can be put into specialized templates.
So here is the original in-line code:
(header)
#include <iostream>
template<int opcode>
class BAR
{
public:
BAR(){};
void foo()
{
std::cout << "BAR<int>::foo()" << std::endl;
}
};
// specialize 1 and 2, otherwise we go with the
// primary definition.
template <>
void BAR<1>::foo()
{
std::cout << "BAR<1>::foo()" << std::endl;
}
template <>
void BAR<2>::foo()
{
std::cout << "BAR<2>::foo()" << std::endl;
}
I have a simple 'main':
int main(int argc, char* argv[])
{
BAR<1> bar_1;
BAR<2> bar_2;
BAR<3> bar_3;
bar_1.foo();
bar_2.foo();
bar_3.foo();
return 0;
}
I managed to put the specializations for '1' and '2' into a cpp file and this is
what I have:
(header)
#include <iostream>
template<int opcode>
class BAR
{
public:
BAR(){};
void foo()
{
std::cout << "BAR<int>::foo()" << std::endl;
}
};
// specialize 1 and 2, otherwise we go with the
// primary definition.
template<> void BAR<1>::foo() ;
template<> void BAR<2>::foo() ;
(cpp)
#include "Foo.h"
#include <iostream>
template<> void BAR<1>::foo()
{
std::cout << "BAR<1>::foo()" << std::endl;
}
template<> void BAR<2>::foo()
{
std::cout << "BAR<2>::foo()" << std::endl;
}
void x()
{
BAR<1> b1;
BAR<2> b2;
b1.foo();
b2.foo();
}
I not real crazy about the x() function, but without this I get unresolved symbols for BAR<1>::foo() & BAR<2>::foo(), if there's a better way, I'd be interested ( MSVC 13 compiler).
Ok so far so good. I really want to put the primary definition of the function foo() into the CPP, but I can't seem to get the syntax right:
template<> void BAR<int>::foo()
{
std::cout << "BAR<int>::foo()" << std::endl;
}
this is not allowed by the compiler, and rightly so I guess, is not
a valid non-type value. So what is the magic words to use to do this?
Many thanks in advance for any help.
dave.