C++: How to call a member function pointer that is a member of the same class?

I'm trying to implement more flexibility in my numerics by allowing me to choose different forms of a mathematical function and vary their parameters through instantiating them as objects of a certain class. That class includes certain mathematical functions I may choose plus parameters that I can vary. The constructor of the class sets a member function pointer in the class to a member function according to what mathematical function I want. I want to solely use the pointer to call whatever function it points to by directly using the pointer in my routine.

However, that proved daunting as I didn't know that member function pointers require a certain syntax and seem to work somewhat differently from regular function pointers according to what I could gather. I've experimented quite a bit and constructed myself a minimal example shared below.

#include<iostream>
#include<string.h>
#include<cstdlib>
#include<stdio.h>

class Someclass
{
public:
    // constructor to set pointer
    Someclass(std::string);

    // member function pointer to hold functions
    void (Someclass::*fptr)();

    // auxiliary function to call testfunction via pointer
    void call ();

    // testfunction
    void foo();
};

// testfunction
void Someclass::foo()
{
    printf("foo says hi! \n");
}

// call via specific function
void Someclass::call()
{
    (this->*fptr)();
}

// constructor
Someclass::Someclass(std::string name)
{
    if(name=="foo")
    {
        this->fptr = &Someclass::foo;
    }
}


int main()
{
    Someclass someobject("foo");

    someobject.foo(); // direct testfunction call: Works OK
    someobject.call(); // call via auxiliary function: Works OK
    //(someobject.*fptr)(); // direct pointer dereferencing: Gives Error

    return(EXIT_SUCCESS);
}

It shows that I can access the pointer by use of another member function that just calls whatever the pointer points to via use of a this pointer. However, I still can't seem to get the function call to work if I try to use the pointer directly in my main function through the line,

(someobject.*fptr)()

This particular expression leads to my compiler complaining about the scope and if I include the class scope, the compiler mentions invalid use of non-static members. Still, I'm confused as to why my implementation here doesn't work and if it does, how the proper syntax in my problem would be and why that has to be so.

Any insights would be really appreciated.