compile-time

How it is determined whether the below call is bound at compile time or at runtime? object.member_fn;//object is either base class or derived class object p->member_fn;//p is either base class or derived class pointer EDITED: #include <iostream> using namespace std; class Base { public: Base(){ cout<<"Constructor: Base"<<endl;} ~Base(){ cout<<"Destructor : Base"<<endl;} }; class Derived: public Base { //Doing a lot of jobs by extending the functionality public: Derived(){ cout<<"Constructor: Derived"<<endl;} ~Derived(){ cout<<"Destructor : Derived"<<endl;} }; void foo() { Base & Var = Derived(

I'm familiar with only one compile time operator in C - sizeof . Are there any others that I as a programmer should be aware of? Only sizeof that I'm aware, although in C99 sizeof cannot be done at compile time for variable length arrays (VLAs). I think what you're grasping for but missing the terminology to describe is a constant expression or integer constant expression . The results of certain operators can be (integer) constant expressions if their operands are, and as you've pointed out, the result of sizeof can be even if its operand is not constant as long as it's not a VLA. See 6.6 in

There is a very easy trick which creates a dictionary-like structure where keys are types. The structure acts like a Dictionary<Type, T?> where keys are Type objects and values are instances of the corresponding types. This wonderful structure is as fast as just a variable or array since the "lookup" is only done once by the compiler/JITter and the proper value reference is compiled into your program. public static class MyDict<T> { public static T Value { get; set; } } You can work with that structure like this: MyDict<string>.Value = MyDict<int>.Value.ToString(); The problem is that this

While working with the reflection class and annotations I have found that there is no clear way to reference a method name in a compile-time safe way. What I really want is to be able to reference a method within an annotation. Might look something like: @CallAfter(method=Foo.class.foo()) void Bar() { ... } At the moment you can only do this with strings, which is not compile time safe.. This is a problem because it undermines Java being statically typed. The only solution I have found is something like what is below. However this still does not help with referencing a method in an annotation.

Going through the second part of Nimrod's tutorial I've reached the part were macros are explained. The documentation says they run at compile time, so I thought I could do some parsing of strings to create myself a domain specific language. However, there are no examples of how to do this, the debug macro example doesn't display how one deals with a string parameter. I want to convert code like: instantiate(""" height,f,132.4 weight,f,75.0 age,i,25 """) …into something which by hand I would write like: var height: float = 132.4 var weight: float = 75.0 var age: int = 25 Obviously this example

I was reading this question on SO. The question itself is not so interesting, but I was wondering whether it exists and how to implement a compile time solution. Regard to the first sequence: All numbers except the ones which can be divided by 3. The sequence should be something like: [1, 2, 4, 5, 7, 8, 10, 11, 13, 14, ...] By induction, I've found the math formula for that sequence: f(0) = 0; f(x > 0) = floor[(3x - 1) / 2]; So I've implemented a C++ constexpr function which generates the i-th number in the sequence: #include <type_traits> template <typename T = std::size_t> constexpr T

Here is my code and I need clarification on what's happening: constexpr int funct(int x){ return x + 1; } int main(){ int x = funct(10); return 0; } constexpr 's allows compile time calculation, and based on my code above, since funct is declared as constexpr , it is allowed to do compile time calculations if the arguments are constants or constexpr's themselves. The part that I am confused with lies in this part, the int x . Since it is not declared as constexpr , would it mean that int x will get the value at runtime? Does that mean that declaring it to be constexpr int x will mean that int