static-methods

I assume this is outright impossible, but what if. Is it possible to somehow get type of enclosing class in a static member function, in any version of C++? class Impossible { public: static void Fun() { typedef Impossible EnclosingClass; // now do something with EnclosingClass ... } } Is there a way to get the type of the enclosing class ( Impossible in this case) without writing the name of the class in the function? The reason why I'd like to do that is to avoid repeating the class name in the function. It could easily lead to a hard to find copy-paste bug, if something like this happened:

Why does the below code print "Main"? public class Main { public static void method() { System.out.println("Main"); } public static void main(String[] args) { Main m = new SubMain(); m.method(); } } class SubMain extends Main { public static void method() { System.out.println("SubMain"); } } At runtime, m is pointing to an instance of Submain , so it should conceptually print "SubMain". Static methods are resolved on the compile-time type of the variable. m is of type Main , so the method in Main is called. If you change it to SubMain m ... , then the method on SubMain will be called. It is

I'm reading Programming Scala . At the beginning of chapter 4, the author comments that Java supports static methods, which are "not-so-pure OO concepts." Why is this so? One reason that static methods aren't very OO that hasn't been mentioned so far is that interfaces and abstract classes only define non-static methods. Static methods thus don't fit very well into inheritance. Note also that static methods do not have access to " super ", which means that static methods cannot be overridden in any real sense. Actually, they can't be overridden at all, only hidden. Try this: public class Test

I'm building an ORM library with reuse and simplicity in mind; everything goes fine except that I got stuck by a stupid inheritance limitation. Please consider the code below: class BaseModel { /* * Return an instance of a Model from the database. */ static public function get (/* varargs */) { // 1. Notice we want an instance of User $class = get_class(parent); // value: bool(false) $class = get_class(self); // value: bool(false) $class = get_class(); // value: string(9) "BaseModel" $class = __CLASS__; // value: string(9) "BaseModel" // 2. Query the database with id $row = get_row_from_db_as

I'm a Java developer who's toyed around with Python on and off. I recently stumbled upon this article which mentions common mistakes Java programmers make when they pick up Python. The first one caught my eye: A static method in Java does not translate to a Python classmethod. Oh sure, it results in more or less the same effect, but the goal of a classmethod is actually to do something that's usually not even possible in Java (like inheriting a non-default constructor). The idiomatic translation of a Java static method is usually a module-level function, not a classmethod or staticmethod. (And

I am a little confused with this matter. I am designing an ORM class that tries to behave very similarly to ActiveRecord in ruby on rails, but that's beside the point. What I'm trying to say is that my class makes extensive use of static attribute inheritance, specially for database and table handling. My question is, should I use self:: at all? DarkThrone You have to ask yourself: "Am I targeting the problem with the adequated approach?" self:: and static:: do two different things. For instance self:: or __CLASS__ are references to the current class, so defined in certain scope it will NOT