More parentheses are required:

    
    (bigCat.*pcat)();
    ^            ^

The function call (`()`) has higher precedence than the pointer-to-member binding operator (`.*`).  The unary operators have higher precedence than the binary operators.

Today, the canonical way is using the [std::invoke][1] function template, especially in generic code. Please note, that the member function pointer comes first:

    import &lt;functional&gt;;

    std::invoke(pcat, bigCat);

What you get: Unified calling syntax for virtually anything, that is invocable.

Overhead: none.


  [1]: https://en.cppreference.com/w/cpp/utility/functional/invoke

Basically, I have a bunch of data where the first column is a string (label) and the remaining columns are numeric values. I run the following:

    data = numpy.genfromtxt(&#39;data.txt&#39;, delimiter = &#39;,&#39;)

This reads most of the data well, but the label column just gets &#39;nan&#39;.  How can I deal with this?

How to use numpy.genfromtxt when first column is string and the remaining columns are numbers?

I&#39;m having an issue with normal (**non-ajax**) functions that involve lots of **animations** within each of them. Currently I simply have a `setTimeout` between functions, but this isn&#39;t perfect since no browsers / computers are the same.

**Additional Note: They both have separate animations/etc that collide.**

I can&#39;t simply put one in the callback function of another

    // multiple dom animations / etc
    FunctionOne();

    // What I -was- doing to wait till running the next function filled
    // with animations, etc

    setTimeout(function () { 
        FunctionTwo(); // other dom animations (some triggering on previous ones)
    }, 1000); 

Is there anyway in js/jQuery to have:

    // Pseudo-code
    -do FunctionOne()
    -when finished :: run -&gt; FunctionTwo()

I know about `$.when()` &amp; `$.done()`, but those are for AJAX...


---------

* **MY UPDATED SOLUTION**

jQuery has an exposed variable (that for some reason isn&#39;t listed anywhere in the jQuery docs) called $.timers, which holds the array of animations currently taking place.

    function animationsTest (callback) {
        // Test if ANY/ALL page animations are currently active
    
        var testAnimationInterval = setInterval(function () {
            if (! $.timers.length) { // any page animations finished
                clearInterval(testAnimationInterval);
                callback();
            }
        }, 25);
    };

Basic useage:

    // run some function with animations etc    
    functionWithAnimations();

    animationsTest(function () { // &lt;-- this will run once all the above animations are finished

        // your callback (things to do after all animations are done)
        runNextAnimations();

    });

Wait till a Function with animations is finished until running another Function

I&#39;m trying to do some testing with member function pointer. What is wrong with this code? The `bigCat.*pcat();` statement doesn&#39;t compile.

    class cat {
    public:
       void walk() {
          printf(&quot;cat is walking \n&quot;);
       }
    };
    
    int main(){
       cat bigCat;
       void (cat::*pcat)();
       pcat = &amp;cat::walk;
       bigCat.*pcat();
    }



How to call through a member function pointer?

I'm trying to do some testing with member function pointer. What is wrong with this code? The <code>bigCat.*pcat();</code> statement doesn't compile.
<pre><code class="hljs language-csharp">class cat {
public:
 void walk() {
 printf("cat is walking \n");
 }
};

int main(){
 cat bigCat;
 void (cat::*pcat)();
 pcat = &#x26;cat::walk;
 bigCat.*pcat();
}
</code></pre>

I&#39;ve started trying out the C++11 standard and i found [this][1] question which describes how to call your ctor from another ctor in the same class to avoid having a init method or the like. Now i&#39;m trying the same thing with code that looks like this:

hpp:

    class Tokenizer
    {
    public:
      Tokenizer();
      Tokenizer(std::stringstream *lines);
      virtual ~Tokenizer() {};
    private:
      std::stringstream *lines;
    };

cpp:

    Tokenizer::Tokenizer()
      : expected(&#39;=&#39;)
    {
    }

    Tokenizer::Tokenizer(std::stringstream *lines)
      : Tokenizer(),
        lines(lines)
    {
    }

But this is giving me the error: 
`In constructor ‘config::Tokenizer::Tokenizer(std::stringstream*)’:
/path/Tokenizer.cpp:14:20: error: mem-initializer for ‘config::Tokenizer::lines’ follows constructor delegation` I&#39;ve tried moving the Tokenizer() part first and last in the list but that didn&#39;t help.


What&#39;s the reason behind this and how should i fix it? I&#39;ve tried moving the `lines(lines)` to the body with `this-&gt;lines = lines;` instead and it works fine. But i would really like to be able to use the initializer list.


  [1]: https://stackoverflow.com/questions/308276/c-call-constructor-from-constructor &quot;this&quot;

Member initialization while using delegated constructor

I&#39;m reading some lecture notes of my C++ lecturer and he wrote the following: 

&gt; 1. Use Indentation // OK
&gt; 2. Never rely on operator precedence - Always use parentheses // OK 
&gt; 3. Always use a { } block - even for a single line // **not OK**, why ???
&gt; 4. Const object on left side of comparison // OK 
&gt; 5. Use unsigned for variables that are &gt;= 0  // nice trick 
&gt; 6. Set Pointer to NULL after deletion - Double delete protection // not bad

The 3rd technique is not clear to me: what would I gain by placing one line in 
a `{ ... }`? 

For example, take this weird code:

	int j = 0;
	for (int i = 0 ; i &lt; 100 ; ++i)
	{
		if (i % 2 == 0)
		{
			j++;
		}
	}

and replace it with: 

	int j = 0;
	for (int i = 0 ; i &lt; 100 ; ++i)
		if (i % 2 == 0)
			j++;


What&#39;s the benefit of using the 1st version? 

What&#39;s the purpose of using braces (i.e. {}) for a single-line if or loop?

It had been my understanding that copy-on-write is not a viable way to implement a conforming `std::string` in C++11, but when it came up in discussion recently I found myself unable to directly support that statement.

Am I correct that C++11 does not admit COW based implementations of `std::string`?

If so, is this restriction explicitly stated somewhere in the new standard (where)?

Or is this restriction implied, in the sense that it is the combined effect of the new requirements on `std::string` that precludes a COW based implementation of `std::string`. In this case, I&#39;d be interested in a chapter and verse style derivation of &#39;C++11 effectively prohibits COW based `std::string` implementations&#39;.

Legality of COW std::string implementation in C++11

I would like some information on how to correctly think about C++11 closures and `std::function` in terms of how they are implemented and how memory is handled.

Although I don&#39;t believe in premature optimisation, I do have a habit of carefully considering the performance impact of my choices while writing new code.  I also do a fair amount of real-time programming, e.g. on microcontrollers and for audio systems, where non-deterministic memory allocation/deallocation pauses are to be avoided.

Therefore I&#39;d like to develop a better understanding of when to use or not use C++ lambdas.

My current understanding is that a lambda with no captured closure is exactly like a C callback.  However, when the environment is captured either by value or by reference, an anonymous object is created on the stack.  When a value-closure must be returned from a function, one wraps it in `std::function`.  What happens to the closure memory in this case?  Is it copied from the stack to the heap?  Is it freed whenever the `std::function` is freed, i.e., is it reference-counted like a `std::shared_ptr`?

I imagine that in a real-time system I could set up a chain of lambda functions, passing B as a continuation argument to A, so that a processing pipeline `A-&gt;B` is created.  In this case, the A and B closures would be allocated once.  Although I&#39;m not sure whether these would be allocated on the stack or the heap.  However in general this seems safe to use in a real-time system.  On the other hand if B constructs some lambda function C, which it returns, then the memory for C would be allocated and deallocated repeatedly, which would not be acceptable for real-time usage.

In pseudo-code, a DSP loop, which I think is going to be real-time safe.  I want to perform processing block A and then B, where A calls its argument.  Both these functions return `std::function` objects, so `f` will be a `std::function` object, where its environment is stored on the heap:

    auto f = A(B);  // A returns a function which calls B
                    // Memory for the function returned by A is on the heap?
                    // Note that A and B may maintain a state
                    // via mutable value-closure!
    for (t=0; t&lt;1000; t++) {
        y = f(t)
    }

And one which I think might be bad to use in real-time code:

    for (t=0; t&lt;1000; t++) {
        y = A(B)(t);
    }

And one where I think stack memory is likely used for the closure:

    freq = 220;
    A = 2;
    for (t=0; t&lt;1000; t++) {
        y = [=](int t){ return sin(t*freq)*A; }
    }

In the latter case the closure is constructed at each iteration of the loop, but unlike the previous example it is cheap because it is just like a function call, no heap allocations are made.  Moreover, I wonder if a compiler could &quot;lift&quot; the closure and make inlining optimisations.

Is this correct?  Thank you.

C++11 lambda implementation and memory model

I don&#39;t need to terminate the thread correctly, or make it respond to a &quot;terminate&quot; command. I am interested in terminating the thread forcefully using pure C++11.

How do I terminate a thread in C++11?

I have read that converting a function pointer to a data pointer and vice versa works on most platforms but is not guaranteed to work. Why is this the case? Shouldn&#39;t both be simply addresses into main memory and therefore be compatible?

Why are function pointers and data pointers incompatible in C/C++?

The question is the following: consider this piece of code:


    #include &lt;iostream&gt;
    
    
    class aClass
    {
    public:
    	void aTest(int a, int b)
    	{
    		printf(&quot;%d + %d = %d&quot;, a, b, a + b);
    	}
    };
    
    void function1(void (*function)(int, int))
    {
    	function(1, 1);
    }
    
    void test(int a,int b)
    {
    	printf(&quot;%d - %d = %d&quot;, a , b , a - b);
    }
    
    int main()
    {
    	aClass a;
    
    	function1(&amp;test);
    	function1(&amp;aClass::aTest); // &lt;-- How should I point to a&#39;s aClass::test function?
    }

How can I use the `a`&#39;s `aClass::test` as an argument to `function1`? I would like to access a member of the class.

How can I pass a member function where a free function is expected?

I only just started learning Python and found out that I can pass a function as the parameter of another function. Now if I call `foo(bar())` it will not pass as a function pointer but the return value of the used function. Calling `foo(bar)` will pass the function, but this way I am not able to pass any additional arguments. What if I want to pass a function pointer that calls `bar(42)`?

I want the ability to repeat a function regardless of what arguments I have passed to it.

    def repeat(function, times):
        for calls in range(times):
            function()

    def foo(s):
        	print s

    repeat(foo(&quot;test&quot;), 4)

In this case the function `foo(&quot;test&quot;)` is supposed to be called 4 times in a row. 
Is there a way to accomplish this without having to pass &quot;test&quot; to `repeat` instead of `foo`? 

How to pass an argument to a function pointer parameter?

I was just going through some code on the Internet and found this:

    float * (*(*foo())[SIZE][SIZE])()

How do I read this declaration? Is there a specific set of rules for reading such complex declarations?


Complex C declaration

It is necessary to me to use `std::function` but I don&#39;t know what the following syntax means.

```
std::function&lt;void()&gt; f_name = []() { FNAME(); };
```

What is the goal of using `std::function`? Is it to make a pointer to a function?

Content Type	Original Author	Original Content on Stackoverflow
Question	Nayana Adassuriya	View Question on Stackoverflow
Solution 1 - C++	James McNellis	View Answer on Stackoverflow
Solution 2 - C++	neonxc	View Answer on Stackoverflow

How to call through a member function pointer?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Wait till a Function with animations is finished until running another Function

How to use numpy.genfromtxt when first column is string and the remaining columns are numbers?

Attributions