No, because it doesn&#39;t make any sense in C++.

Virtual functions are invoked when you have a pointer/reference **to an instance** of a class.  Static functions aren&#39;t tied to a particular instance, they&#39;re tied to a class.  C++ doesn&#39;t have pointers-to-class, so there is no scenario in which you could invoke a static function virtually.

That would make no sense. The point of *virtual* member functions is that they are dispatched based on the dynamic type of the *object instance* on which they are called. On the other hand, static functions are not related to any instances and are rather a property of the *class*. Thus it makes no sense for them to be virtual. If you must, you can use a non-static dispatcher:

    struct Base
    {
        static void foo(Base &amp; b) { /*...*/ }

        virtual ~Base() { }
        virtual void call_static() { foo(*this); /* or whatever */ }
    };

    struct Derived : Base
    {
         static void bar(int a, bool b) { /* ... */ }

         virtual void call_static() { bar(12, false); }
    };

Usage:

    Base &amp; b = get_instance();
    b.call_static();   // dispatched dynamically

    // Normal use of statics:
    Base::foo(b);
    Derived::bar(-8, true);

Is there any convenient way to take an array/set of objects and create a new array/set containing some property of each item in the first array?

For example, an array contains Car objects.  I need an array of licensePlates, where each car has an NSObject car.licensePlate.

Currently I just iterate through the first array adding objects to my mutable results array, but was wondering if there is an instantiation method that exists for this (checked the docs for NSArray).

Creating an array from properties of objects in another array

So I looked into this &quot;enum&quot; type, and it kind of seems like a glorified *array*/`ArrayList`/`List` to me. What exactly is the use of it? 

What&#39;s the use of &quot;enum&quot; in Java?

&gt; **Possible Duplicate:**  
&gt; [C++ static virtual members?](https://stackoverflow.com/questions/1820477/c-static-virtual-members)  

&lt;!-- End of automatically inserted text --&gt;

Can we have a static virtual functions? If not, then WHY?

    class X
    {
    public:
           virtual static void fun(){} // Why we cant have static virtual function in C++?
    };

Can we have a static virtual functions? If not, then WHY?

> Possible Duplicate: 
> <a href="https://stackoverflow.com/questions/1820477/c-static-virtual-members" target="_blank" rel="noopener noreferrer">C++ static virtual members?</a>

Can we have a static virtual functions? If not, then WHY?
<pre><code class="hljs language-csharp">class X
{
public:
 virtual static void fun(){} // Why we cant have static virtual function in C++?
};
</code></pre>

I would like to find a better algorithm to solve the following problem:

There are _N_ starting points (purple) and _N_ target points (green) in 2D. I want an algorithm that connects starting points to target points by a line segment (brown) without any of these segments intersecting (red) and while minimizing the cumulative length of all segments.

My first effort in C++ was permuting all possible states, find intersection-free states, and among those the state with minimum total segment length  *O(n!)* . But I think there has to be a better way.

![enter image description here][1]

Any idea? Or good keywords for search?


  [1]: http://i.stack.imgur.com/h17NF.png

Non-intersecting line segments while minimizing the cumulative length

If I have a class Foo in namespace bar:

    namespace bar
    {
        class Foo { ... }
    };

I can then:

    using Baz = bar::Foo;

and now it is just like I defined the class in my namespace with the name Baz.

Is it possible to do the same for functions?

    namespace bar
    {
        void f();
    }

And then:

    using g = bar::f; // error: ‘f’ in namespace ‘bar’ does not name a type

What is the cleanest way to do this?

The solution should also hold for template functions.

__Definition:__ If some entity B is an __alias__ of A, than if any or all usages (not declarations or definitions of course) of A are replaced by B in the source code than the (stripped) generated code remains the same.  For example `typedef A B` is an alias.  `#define B A` is an alias (at least).  `T&amp; B = A` is not an alias, B can effectively implemented as an indirect pointer, wheres an &quot;unaliased&quot; A can use &quot;immediate semantics&quot;.


C++11: How to alias a function?

I&#39;m used to manually install GCC from source before on Ubuntu and it was a painful process. So I really don&#39;t want to do repeat this process. Currently, I have MinGW and GCC (4.6.2) installed on my machine. So is there an easy way to update GCC without building it entirely from source? Has anyone done it before can share me some tips?



How to update GCC in MinGW on Windows?

How can I get the maximum or minimum value in a vector in C++?

And am I wrong in assuming it would be more or less the same with an array?

I need an iterator, right? I tried it with `max_element`, but I kept getting an error.

    vector&lt;int&gt;::const_iterator it;
    it = max_element(cloud.begin(), cloud.end());

```
error: request for member ‘begin’ in ‘cloud’, which is of non-class type ‘int [10]’
```







How can I get the maximum or minimum value in a vector?

So the following code makes 0 &lt; r &lt; 1 

    r = ((double) rand() / (RAND_MAX))


Why does having  `r = ((double) rand() / (RAND_MAX + 1))` make -1 &lt; r &lt; 0?

Shouldn&#39;t adding one to RAND_MAX make 1 &lt; r &lt; 2?


Edit: I was getting a  warning: integer overflow in expression

on that line, so that might be the problem. I just did `cout &lt;&lt; r &lt;&lt; endl` and it definitely gives me values between -1 and 0



rand() between 0 and 1

I&#39;m getting an error from the following code using C++.

**Main.cpp**

    #include &quot;file.h&quot;

    int main()
    {
       int k = GetInteger();
       return 0;
    }

**File.h**

    static int GetInteger();

**File.cpp**

    #include &quot;file.h&quot;

    static int GetInteger()
    {
       return 1;
    }

The error I get:

    Error C2129: static function &#39;int GetInteger(void)&#39; declared but not defined.

I&#39;ve read the famous article [&quot;Organizing Code File in C and C++&quot;][1], but don&#39;t understand what is wrong with this code.


  [1]: http://www.gamedev.net/page/resources/_/technical/general-programming/organizing-code-files-in-c-and-c-r1798

Static function declared but not defined in C++

I have a class `Person` and a static method in that class called `call_person`:

    class Person:
        def call_person():
            print &quot;hello person&quot;

In the python console I import the class Person and call `Person.call_person()`. But it is giving me error that says `&#39;module&#39; object has no attribute &#39;call_person&#39;`. Can anyone please let me know why I am getting this error?

Calling static method in python

I&#39;m a Java developer who&#39;s toyed around with Python on and off. I recently stumbled upon [this article](http://dirtsimple.org/2004/12/python-is-not-java.html) which mentions common mistakes Java programmers make when they pick up Python. The first one caught my eye:
&gt; 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&#39;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 static final fields should translate to module-level constants.)

&gt; This isn&#39;t much of a performance issue, but a Python programmer who has to work with Java-idiom code like this will be rather irritated by typing Foo.Foo.someMethod when it should just be Foo.someFunction. But do note that calling a classmethod involves an additional memory allocation that calling a staticmethod or function does not.

&gt; Oh, and all those Foo.Bar.Baz attribute chains don&#39;t come for free, either. In Java, those dotted names are looked up by the compiler, so at runtime it really doesn&#39;t matter how many of them you have. In Python, the lookups occur at runtime, so each dot counts. (Remember that in Python, &quot;Flat is better than nested&quot;, although it&#39;s more related to &quot;Readability counts&quot; and &quot;Simple is better than complex,&quot; than to being about performance.)

I found this a bit strange because the documentation for [staticmethod](http://docs.python.org/py3k/library/functions.html#staticmethod) says:
&gt; Static methods in Python are similar to those found in Java or C++. Also see classmethod() for a variant that is useful for creating alternate class constructors.

Even more puzzling is that this code:
  
    class A:
        def foo(x):
            print(x)
    A.foo(5)

Fails as expected in Python 2.7.3 but works fine in 3.2.3 (although you can&#39;t call the method on an instance of A, only on the class.)

So there&#39;s three ways to implement static methods (four if you count using classmethod), each with subtle differences, one of them seemingly undocumented. This seems at odds with Python&#39;s mantra of &lt;i&gt;There should be one-- and preferably only one --obvious way to do it.&lt;/i&gt; Which idiom is the most Pythonic? What are the pros and cons of each?

Here&#39;s what I understand so far:

&lt;b&gt;Module function:&lt;/b&gt;

* Avoids the Foo.Foo.f() problem
* Pollutes the module&#39;s namespace more than the alternatives
* No inheritance

&lt;b&gt;staticmethod:&lt;/b&gt;

* Keeps functions related to the class inside the class and out of the module namespace.
* Allows calling the function on instances of the class.
* Subclasses can override the method.

&lt;b&gt;classmethod:&lt;/b&gt;

* Identical to staticmethod, but also passes the class as the first argument.

&lt;b&gt;Regular method (Python 3 only)&lt;/b&gt;:

* Identical to staticmethod, but can&#39;t call the method on instances of the class.

Am I overthinking this? Is this a non-issue? Please help!

Module function vs staticmethod vs classmethod vs no decorators: Which idiom is more pythonic?

I was just reading over the text given to me in my textbook and I&#39;m not really sure I understand what it is saying. It&#39;s basically telling me that static methods or class methods include the &quot;modifier&quot; keyword static. But I don&#39;t really know what that means?

Could someone please explain to me in really simple terms what Static or Class Methods are?

Also, could I get a simple explanation on what Instance methods are?

This is what they give me in the textbook:

&gt; There are important practical implications of the presence or absence of the static modifier. A public class method may be invoked and executed as soon as Java processes the definition of the class to which it belongs. That is not the case for an instance method. Before a public instance method may be invoked and executed, an instance must be created of the class to which it belongs. To use a public class method, you just need the class. On the other hand, before you can use a public instance method you must have an instance of the class.
&gt;
&gt; The manner in which a static method is invoked within the definition of another method varies according to whether or not the two methods belong to the same class. In the example above, factorial and main are both methods of the MainClass class. As a result, the invocation of factorial in the definition of main simply references the method name, &quot;factorial&quot;.

Difference between Static methods and Instance methods

Could someone explain to me the meaning of `@classmethod` and `@staticmethod` in python? I need to know the difference and the meaning. 

As far as I understand, `@classmethod` tells a class that it&#39;s a method which should be inherited into subclasses, or... something. However, what&#39;s the point of that? Why not just define the class method without adding `@classmethod` or `@staticmethod` or any `@` definitions?

**tl;dr:** *when* should I use them, *why* should I use them, and *how* should I use them?


Meaning of @classmethod and @staticmethod for beginner?

[Wikipedia](http://en.wikipedia.org/wiki/C%2B%2B11#Explicit_overrides_and_final) has the following example on the C++11 final modifier:

    struct Base2 {
        virtual void f() final;
    };
     
    struct Derived2 : Base2 {
        void f(); // ill-formed because the virtual function Base2::f has been marked final
    };

I don&#39;t understand the point of introducing a virtual function and immediately marking it as final. Is this simply a bad example, or is there more to it?

What&#39;s the point of a final virtual function?

As far as I understand, the introduction of `override` keyword in C++11 is nothing more than  a check to make sure that the function being implemented is the `override`ing of a `virtual` function in the base class.

Is that it?

Is the &#39;override&#39; keyword just a check for a overridden virtual method?

In Java you can mark method as final to make it *impossible* to override.

In C# you have to mark method as virtual to make it *possible* to override.

Does it mean that in C# you should mark all methods virtual (except a few ones that you don&#39;t want to be overridden), since most likely you don&#39;t know in what way your class can be inherited?

Should I mark all methods virtual?

Here is some code from [MSDN][1]:

    // compile with: /target:library 
    public class D
    {
        public virtual void DoWork(int i)
        {
            // Original implementation.
        }
    }
    
    public abstract class E : D
    {
        public abstract override void DoWork(int i);
    }
    
    public class F : E
    {
        public override void DoWork(int i)
        {
            // New implementation.
        }
    }

  [1]: http://msdn.microsoft.com/en-us/library/ms173150.aspx

Can anyone explain the above code with respect to the differences between abstract and virtual methods?

Difference between virtual and abstract methods

As I understand it, the `override` keyword states that a given declaration implements a base `virtual` method, and the compilation should fail if there is no matching base method found.

My understanding of the `final` keyword is that it tells the compiler that no class shall override this `virtual` function.

So is `override final` redundant? [It seems to compile fine][1]. What information does `override final` convey that `final` does not? What is the use case for such a combination?


  [1]: http://ideone.com/9V7zNx

Content Type	Original Author	Original Content on Stackoverflow
Question	Jatin	View Question on Stackoverflow
Solution 1 - C++	Oliver Charlesworth	View Answer on Stackoverflow
Solution 2 - C++	Kerrek SB	View Answer on Stackoverflow

Can we have a static virtual functions? If not, then WHY?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

What's the use of "enum" in Java?

Creating an array from properties of objects in another array

Attributions