compile-time

Suppose some function that always gets some parameter s that it does not use. def someFunc(s): # do something _not_ using s, for example a=1 now consider this call someFunc("the unused string") which gives a string as a parameter that is not built during runtime but compiled straight into the binary (hope thats right). The question is: when calling someFunc this way for, say, severalthousand times the reference to "the unused string" is always passed but does that slow the program down? in my naive thoughts i'd say the reference to "the unused string" is 'constant' and available in O(1) when a

I need to implement some variadic template container class with heterogeneous elements, which allows to iterate by these elements. My first idea is make class with std::tuple member with variadic arguments, but getting elements from tuple by array-like manner (via loops) is impossible: struct A {void prnt(){std::cout<<"A\n";} }; struct B {void prnt(){std::cout<<"B\n";} }; struct C {void prnt(){std::cout<<"C\n";} }; template<typename...Arg> struct Prc { Prc() : NumElems(sizeof...(Arg)), mems(std::make_tuple(Arg()...)){} int NumElems; std::tuple<Arg...> mems; void process() { for(int i=0; i

While I know you cannot actually get the type of a generic at runtime because of type erasure, I was wondering if it is possible to get it at compile time. class ObjectHandle<T extends ObjType> { T obj; void setObj(T o) { obj = o; } } class ObjType {} class SubObjType extends ObjType {} ... ObjectHandle<SubObjType> handle = new ObjectHandle<SubObjType>(); ... ObjType obj = [method that returns an ObjType]; if(obj instanceof [handle's generic class, here SubObjType]) { handle.setObj(obj); // cast??? } Here the compiler knows the type of the generic of handle and what I want is something so I

In C#, is it possible to restrict who can call a method at compile time? I've looked into directives, but that didn't work since I can't assign values to symbols. #define WHO VisualStudioUser.Current // does not work I also looked into Code Access Security (CAS) but that's runtime enforcement, not compile time. The requirement is to restrict access to a method at compile time for specific developers given the method exists in a pre-compiled assembly. here's more details... I'm building a framework or a series or assemblies for a team of developers. Because of our software license restrictions,

Is there a Java equivalent to the C & C++ compile-time constants __DATE__ and __TIME__. I need to print compile time and version info of the program being compiled. Thanks kodev19 As far as i know, there is nothing like that. But on a running JVM you can get a few informations straight away from the jar using something like the code below (here, the information comes from the Manifest file put in the jar at compilation time (which ever your build system is, Ant or Maven or anything else). Feel free to adapte it (different output, and so on). public String getVersionfinal Class classe) { String

Visual C++ has #pragma message that outputs a string into compiler output . Now I have a factory: template<class Type> CComPtr<Type> CreateComObject() { CComPtr<Type> newObject( new CComObject<Type> ); //do some tuning to the object return newObject; } and I want to output the size of class that is passed to new (namely sizeof( CComObject<Type> ) into the compiler output. Looks like #pragma message only accepts strings. How can I output a compile-time numeric constant? Nawaz If I understood your question correctly, then I think you can do this: template<size_t size> struct overflow{ operator

Inspired by this question , i'm wondering if there is some compile-time check one can introduce to detect if two given template instantiations: template <typename T> class Templ... typedef Templ<std::string> stringInstance; typedef Templ<double> doubleInstance; are constructed from the same definition, or if they are built from different specializations of the Templ template so basically the hypothetical template function will behave like this: template <typename T> class Templ {} template <> class Templ<std::string> {} template <> class Templ<double> {} template <typename T1,typename T2>