I have the following class structure:  class X {     // ... };  class Y : public X {     // ... };  class IA { public:      virtual void Foo(X* x) = 0; };  class A : public IA { public:      void Foo(Y* y)     {         Foo(static_cast&lt;X*&gt;(y));     } };  class B : public A { public:      virtual void Foo(X* x) override     {         // ...     } };   However, this code generates compiler errors:  error C2664: 'void A::Foo(Y *)': cannot convert argument 1 from 'X *' to 'Y *'   The way to fix it is to replace A::Foo(Y*) with this:  void Foo(Y* y) {     static_cast&lt;IA*&gt;(this)-&gt;Foo(static_cast&lt;X*&gt;(y)); }   I have trouble understanding why this cast is necessary, and would appreciate some insight. I'm not quite sure if this is guaranteed to be a safe cast either.  To my understanding during overload resolution, the compiler should select the function that requires the least amount of implicit casting for the parameters. But that doesn't seem to be the case here.
17714
I have a function with the same name, but with different signature in a base and derived classes. When I am trying to use the base class's function in another class that inherits from the derived, I receive an error. See the following code:  class A {     public:     void foo(string s){}; };  class B : public A {     public:     int foo(int i){}; };  class C : public B {     public:     void bar()     {         string s;         foo(s);     } };   I receive the following error from the gcc compiler:  In member function `void C::bar()': no matching function for call to `C::foo(std::string&amp;)' candidates are: int B::foo(int)   If I remove int foo(int i){}; from class B, or if I rename it from foo1, everything works fine.   What's the problem with this?
47950
Why don't more mainstream statically typed languages support function/method overloading by return type?  I can't think of any that do.  It seems no less useful or reasonable than supporting overload by parameter type.  How come it's so much less popular?
33845
Let's say I have a function that accepts a void (*)(void*) function pointer for use as a callback:  void do_stuff(void (*callback_fp)(void*), void* callback_arg);   Now, if I have a function like this:  void my_callback_function(struct my_struct* arg);   Can I do this safely?  do_stuff((void (*)(void*)) &amp;my_callback_function, NULL);   I've looked at  and I've looked at some C standards which say you can cast to 'compatible function pointers', but I cannot find a definition of what 'compatible function pointer' means.
16896
I have a generic class that I'm trying to implement implicit type casting for.  While it mostly works, it won't work for interface casting.  Upon further investigation, I found that there is a compiler error: "User-defined conversion from interface" that applies.  While I understand that this should be enforced in some cases, what I'm trying to do does seem like a legitimate case.  Here's an example:  public class Foo&lt;T&gt; where T : IBar {     private readonly T instance;      public Foo(T instance)     {         this.instance = instance;     }     public T Instance     {         get { return instance; }     }     public static implicit operator Foo&lt;T&gt;(T instance)     {         return new Foo&lt;T&gt;(instance);     } }   Code to use it:  var concreteReferenceToBar = new ConcreteBar(); IBar intefaceReferenceToBar = concreteReferenceToBar; Foo&lt;ConcreteBar&gt; concreteFooFromConcreteBar = concreteReferenceToBar; Foo&lt;IBar&gt; fooFromConcreteBar = concreteReferenceToBar; Foo&lt;IBar&gt; fooFromInterfaceBar = intefaceReferenceToBar; // doesn't work   Does anyone know a workaround, or can anyone explain in a satisfactory way why I shuouldn't be able to cast interfaceReferenceToBar implicitly to Foo&lt;IBar&gt;, since in my case it is not being converted, but only contained within Foo?  EDIT: It looks like covariance might offer salvation.  Let's hope the C# 4.0 specification allows for implicit casting of interface types using covariance.
18114
I have a method with an out parameter that tries to do a type conversion. Basically:  public void GetParameterValue(out object destination) {     object paramVal = "I want to return this. could be any type, not just string.";      destination = null; // default out param to null     destination = Convert.ChangeType(paramVal, destination.GetType()); }   The problem is that usually someone would call this like:  string output; GetParameterValue(output);   This will fail because of:  destination.GetType()   destination is null, so we can't call .GetType() on it. We also can not call:  typeof(destination)   because destination is a variable name not a type name.  So is there any way to get the type of an object that is set to null? I would think there would have to be a way to know what type a storage location is without it being assigned anything.    Just to give a bit more info, I am trying to make a utility method that will grab the output parameters of an Oracle stored procedure. The issue is that DbParameter.Value is of type object.  What would be ideal would be for the developers to do something like:  string val = GetParameterValue("parameterName");   The notable thing is that there is no casting of types. In practice, you don't know the lparam of the "equals", so I went with:  string val; GetParameterValue("parameterName", out val);   And figured within the method, I would know the destination type of the output variable. I guess that was a bad assumption. As an alternative, I also wrote the method:  public T GetParameterValue&lt;T&gt;(string paramName)   So the developers can do:  string val = GetParameterValue&lt;string&gt;("parameterName");   I find the explicit "string" declaration to be repetitive, especially since in practice, the destination if probably an object property and the oracle data type could change (think ORM):  MyObj.SomeProp = GetParameterValue&lt;MyObj.SomeProp.GetType()&gt;("parameterName");   But again, if MyObj.SomeProp is null, that .GetType() call fails. The VM has to know the type of MyObj.SomeProp, even when its null, right? or else how would it catch cast exceptions?    To partially solve my own problem, I can do:  MyObj.SomeProp = GetParameterValue&lt;typeof(MyObj).GetField("SomeProp").GetType()&gt;("parameterName");   The whole idea was to not have to explicitly use the Type in more than one place, so that if the data type changes, it only has to be changed in the destination object (MyObj.SomeProp) and in the DB. There has to be a better way...
69502
Possible Duplicate:          Would someone explain the differences between these two beasts and how to use them. AFAIK, many  pre.2.0 classes were implemented without generic types, thus causing latter version to implement both flavors of interfaces. Is the the only case why one would need to use them?  Can you also explain in depth how to use them.?  Thanks
19900
I have just found a static nested interface in our code-base.  class Foo {     public static interface Bar {         /* snip */     }     /* snip */ }   I have never seen this before. The original developer is out of reach. Therefore I have to ask SO:  What are the semantics behind a static interface? What would change, if I remove the static? Why would anyone do this?
22280
I've been writing C and C++ code for almost twenty years, but there's one aspect of these languages that I've never really understood. I've obviously used regular casts i.e.  MyClass *m = (MyClass *)ptr;   all over the place, but there seem to be two other types of casts, and I don't know the difference. What's the difference between the following lines of code?  MyClass *m = (MyClass *)ptr; MyClass *m = static_cast&lt;MyClass *&gt;(ptr); MyClass *m = dynamic_cast&lt;MyClass *&gt;(ptr);
88139
I am wondering why the C# 3.0 compiler is unable to infer the type of a method when it is passed as a parameter to a generic function when it can implicitly create a delegate for the same method.  Here is an example:  class Test {     static void foo(int x) { }     static void bar&lt;T&gt;(Action&lt;T&gt; f) { }      static void test()     {         Action&lt;int&gt; f = foo; // I can do this         bar(f); // and then do this         bar(foo); // but this does not work     }    }   I would have thought that I would be able to pass foo to bar and have the compiler infer the type of Action&lt;T&gt; from the signature of the function being passed but this does not work.  However I can create an Action&lt;int&gt; from foo without casting so is there a legitimate reason that the compiler could not also do the same thing via type inference?
65547
See also      Not a major issue, just annoying as I don't want my class to ever be instantiated without the particular arguments.  #include &lt;map&gt;  struct MyClass {     MyClass(int t); };  int main() {     std::map&lt;int, MyClass&gt; myMap;     myMap[14] = MyClass(42); }   This gives me the following g++ error:     /usr/include/c++/4.3/bits/stl_map.h:419: error: no matching function for call to ‘MyClass()’   This compiles fine if I add a default constructor; I am certain it's not caused by incorrect syntax.
77597
I got this question when I received a code review comment saying virtual functions need not be inline.   I thought inline virtual functions could come in handy in scenarios where functions are called on objects directly. But the counter-argument came to my mind is -- why would one want to define virtual and then use objects to call methods?  Is it best not to use inline virtual functions, since they're almost never expanded anyway?  Code snippet I used for analysis:  class Temp { public:      virtual ~Temp()     {     }     virtual void myVirtualFunction() const     {         cout&lt;&lt;"Temp::myVirtualFunction"&lt;&lt;endl;     }  };  class TempDerived : public Temp { public:      void myVirtualFunction() const     {         cout&lt;&lt;"TempDerived::myVirtualFunction"&lt;&lt;endl;     }  };  int main(void)  {     TempDerived aDerivedObj;     //Compiler thinks it's safe to expand the virtual functions     aDerivedObj.myVirtualFunction();      //type of object Temp points to is always known;     //does compiler still expand virtual functions?     //I doubt compiler would be this much intelligent!     Temp* pTemp = &amp;aDerivedObj;     pTemp-&gt;myVirtualFunction();      return 0; }
2689
What is the idiomatic Python equivalent of this C/C++ code?  void foo() {     static int counter = 0;     counter++;     printf("counter is %d\n", counter); }   specifically, how does one implement the static member at the function level, as opposed to the class level? And does placing the function into a class change anything?
95803
I'm having problems trying to overload the post increment operator in C#. Using integers we get the following results.  int n;  n = 10; Console.WriteLine(n); // 10 Console.WriteLine(n++); // 10 Console.WriteLine(n); // 11  n = 10; Console.WriteLine(n); // 10 Console.WriteLine(++n); // 11 Console.WriteLine(n); // 11   But, when I try it using classes, it looks like the objects are exchanged.  class Account {     public int Balance { get; set; }     public string Name { get; set; }      public Account(string name, int balance)     {         Balance = balance;         Name = name;     }      public override string ToString()     {         return Name + " " + Balance.ToString();     }      public static Account operator ++(Account a)     {         Account b = new Account("operator ++", a.Balance);         a.Balance += 1;         return b;     }      public static void Main()     {         Account a = new Account("original", 10);          Console.WriteLine(a); // "original 10"          Account b = a++;          Console.WriteLine(b); // "original 11", expected "operator ++ 10"         Console.WriteLine(a); // "operator ++ 10", expected "original 11"     } }   Debugging the application, the overloaded operator method, returns the new object with the old value (10) and the object that has been passed by reference, has the new value (11), but finally the objects are exchanged. Why is this happening?
51146
Here is an example of polymorphism from  (edited for readability):  // abstract base class #include &lt;iostream&gt; using namespace std;  class Polygon {     protected:         int width;         int height;     public:         void set_values(int a, int b) { width = a; height = b; }         virtual int area(void) =0; };  class Rectangle: public Polygon {     public:         int area(void) { return width * height; } };  class Triangle: public Polygon {     public:         int area(void) { return width * height / 2; } };  int main () {     Rectangle rect;     Triangle trgl;     Polygon * ppoly1 = &amp;rect;     Polygon * ppoly2 = &amp;trgl;     ppoly1-&gt;set_values (4,5);     ppoly2-&gt;set_values (4,5);     cout &lt;&lt; ppoly1-&gt;area() &lt;&lt; endl; // outputs 20     cout &lt;&lt; ppoly2-&gt;area() &lt;&lt; endl; // outputs 10     return 0; }   My question is how does the compiler know that ppoly1 is a Rectangle and that ppoly2 is a Triangle, so that it can call the correct area() function? It could find that out by looking at the "Polygon * ppoly1 = &rect;" line and knowing that rect is a Rectangle, but that wouldn't work in all cases, would it? What if you did something like this?  cout &lt;&lt; ((Polygon *)0x12345678)-&gt;area() &lt;&lt; endl;   Assuming that you're allowed to access that random area of memory.  I would test this out but I can't on the computer I'm on at the moment.  (I hope I'm not missing something obvious...)
81728
Why is the following C# code not allowed:  public abstract class BaseClass {     public abstract int Bar { get;} }  public class ConcreteClass : BaseClass {     public override int Bar     {         get { return 0; }         set {}     } }      CS0546 'ConcreteClass.Bar.set': cannot override because 'BaseClass.Bar' does not have an overridable set accessor
1377
Is there any good reason that an empty set of round brackets (parentheses) isn't valid for calling the default constructor in C++?  MyObject  object;  // ok - default ctor MyObject  object(blah); // ok  MyObject  object();  // error   I seem to type "()" automatically everytime. Is there a good reason this isn't allowed?
8090
I have a file: Base.h  class Base; class DerivedA : public Base; class DerivedB : public Base;  /*etc...*/   and another file: BaseFactory.h  #include "Base.h"  class BaseFactory { public:   BaseFactory(const string &amp;sClassName){msClassName = sClassName;};    Base * Create()   {     if(msClassName == "DerivedA")     {       return new DerivedA();     }     else if(msClassName == "DerivedB")     {       return new DerivedB();     }     else if(/*etc...*/)     {       /*etc...*/     }   }; private:   string msClassName; };  /*etc.*/   Is there a way to somehow convert this string to an actual type (class), so that BaseFactory wouldn't have to know all the possible Derived classes, and have if() for each one of them? Can I produce a class from this string?   I think this can be done in C# through Reflection. Is there something similar in C++?