Use of "*" in something like, "char *someVariable;"

>>>> what does the "*" do for "someVariable" in that position?
The position of the asterisk * may be somewhere between the type specifier and the variablename. C++ programmers mostly see the * as part of the type (making it a pointer type) rather than just have a different view on the variable (viewing it indirectly by its address). C programmers often put the asterisk to the variable, so as with your sample code.

The advantage of a pointer variable is that you can use the same variable pointing to different objects:

    string str1 = "abc";
    string str2 = "xyz";
    string * pstr = &str1; // initially points to str1
    pstr = &str2;   // now points to str2

You even can set a pointer variable to a 'nil' value:

    string * pstr = NULL;

The NULL at the right side is a macro that is equivalent to a integer 0 (that has historical reasons). So, different to a object you can check a pointer if it is valid by checking if it is NULL:

    if (pstr == NULL)
         pstr = new string("Hello World");

Here we create a dynamic object (at the heap) by calling 'new' operator. The 'new' operator always returns a pointer to the object created. By

    string str = "any text";

we create a object at the stack.  The object is valid as long as the current scope which is defined  by a sequence of statements within curly brackets { }   was not left:

   if (any_condition)
   {
      string str = "any text";
      ...
    }    
   // coming here the variable str isn't valid.

If you created a object by 'new'  it keeps valid beyond the scope boundaries. It must be 'deleted' explicitly to free the storage (and run the destructor function if it is a class object).

    string* pstr = NULL;
    if (any_condition)
    {
       pstr = new string("any text");
       ...
    }
    // pstr is still valid if any_condition was true
    if (pstr != NULL)
    {
           dosomething(pstr);
           delete pstr;    // delete the pointer after use
    }

Note, if you don't delete pointers after use, you'll have a so-called memory leak that is a storage in memory that never was freed and therefore can't be used for other purposes.

If you have a pointer to a class object you will use the arrow operator -> to access data members or function members of the class:

class X
{
public:
     int i;
     void anyFunc();
};

    X* px = new X;   // creates a X using the default constructor
    px->i = 5;   // assign to data member
    px->anyFunc();  // call member function
    delete px;  

For stack object the same sequence is

   {
      X x;
      x.i = 5;
      x.anyFunc();
   }  
   // here x was destroyed

There are three main reasons for using pointers over objects:

1. When passed to a function, only an address needs to
    be passed and not a (maybe big) data structure.
2. When having a class tree with baseclasses and derived classes,
    you can access objects of different derived classes via
    baseclass pointer.
 
    class Base
    {
           virtual void do() = 0;
    };
    class Derived1 : public Base
    {
           virtual void do() { dosomething(); }
    };
    class Derived2 : public Base
    {
           virtual void do() { dosomthingelse(); }
     };
    Derived1 d1;
    Derived2 d2;
    Base* pBase = NULL);
    if (any_condition)
         pBase = &d1;
    else
         pBase = &d2;
    // now call do member function virtually !!!
    pBase->do();

    The latter calls the overloaded do function of either derived class.

3. When using a array  in C/C++ it was treated like a pointer to the first element:

    void func (int* parr, int siz)
    {
          for (int i = 0; i < siz; ++i)
               parr[i] = i;
    }

     int arr[10];  // define a array of 10 integers
     func(arr, 10);    // passing a array
     int* parr = new int[10];   // create 10 integers at the heap
     func(parr, 10);  // passing a pointer (dynamic array)

You see, the array variable 'arr' turned to a pointer variable when passed to a function. Note, the 'p' I added to any pointer variable is convention only. In the called function you can't find out the size of the array. That's why I passed an additional size argument (what is highly recommended but optional).

As Axter explained you should avoid pointers in C++ if possible. Case 1 can be easily solved by using a reference type when passing objects to functions. A reference is an address same as a pointer but it is  a valid address and cannot be NULL or invalid. Case 3 can be solved by using a container object like std::string or std::vector which allows to define dynamic 'arrays' and pass them by value or by reference. For case 2 you can use a baseclass reference when passing a derived object to a function. You only need to use baseclass pointers when storing the pointers (addresses) to a container. But that wasn't a problem for a newbee.

Regards, Alex