#include <iostream>
 
int main()
{
    const char* puntero_probablemente_a_zona_de_solo_lectura = "hola";  // segmento "data" en el ejecutable
    std::cout << "apunta al string literal: \"" << puntero_probablemente_a_zona_de_solo_lectura << "\"\n";
    std::cout << "su direccion es: "
        << (void*)puntero_probablemente_a_zona_de_solo_lectura << "\n\n";
 
    const char* puntero_a_heap = new char[6] { "adios" };  // asignación "dinámica" en heap, usa new / delete
    std::cout << "apunta a la C string en heap: \"" << puntero_a_heap << "\"\n";
    std::cout << "su direccion es: "
        << (void*)puntero_a_heap << "\n\n";
    delete[] puntero_a_heap;
 
    char ch = 'a';
    const char* puntero_a_stack = &ch;  // en el stack frame de main
    std::cout << "apunta al char en stack: \'" << *puntero_a_stack << "\'\n";
    std::cout << "su direccion es: "
        << (void*)puntero_a_stack << "\n\n";
 
}

Las variables no son visibles (a los meros usuarios de getch y de ungetch) porque tienen sus nombres ocultos (gracias a que han sido declaradas "static"). 

#include <stdio.h>
#define BUFSIZE 100
 
static char buf[BUFSIZE];  ///< ahora buf esta declarada "static"
static int bufp = 0;       ///< bufp tambien.             
itn getch(void) {
   ...
}
 
void ungetch(int) {
   ...
}

Al declarar las variables globales como "static", se está prohibiendo su acceso desde otros archivos (se ocultan sus nombres, ya no serán visibles desde otros archivos, incluso aunque algún pícaro o descuidado las declare "extern")

#include <iostream>
 
class UnaClase {
public:
    void unMetodo()
    {
        std::cout << "UnaClase::unMetodo()\n";
    }
};
 
void unaFuncion(UnaClase* p, void(UnaClase::* pmf)())
{
    (p->*pmf)();  ///< recien aqui se define a que funcion de que objeto apunta el "puntero a funcion miembro" (pmf)
}
 
int main()
{
    UnaClase unaClase;
    unaFuncion(&unaClase, &UnaClase::unMetodo);  ///< debe invocarse con el objeto ademas del "puntero a funcion miembro";
                                                 ///< y si la funcion miembro toma parametros, tambien habra que pasarselos.
}

namespace Stuffs {
    class UnaCosa {
    public: ///< En C++ getTrue debe ser public para que pueda ser accedida desde fuera.
        static bool getTrue() /*const*/ {  ///< En C++ una funcion miembro static no puede tener calificador de tipo
            return true;
        }
    };
}
 
int main() {
    bool unaExpresion = Stuffs::UnaCosa::getTrue();
 
    //una instancia a UnaCosa
    Stuffs::UnaCosa unaCosa;
    unaCosa.getTrue();     //Esto deberia dar error verdad?
                           ///< En C++ es una expresion valida, equivalente a Stuffs::UnaCosa::getTrue();
 
    //puntero
    Stuffs::UnaCosa* p_unaCosa = new Stuffs::UnaCosa;
    p_unaCosa->getTrue();   //Esto tambien deberia dar error, si?
                            ///< En C++ es una expresion valida, equivalente a Stuffs::UnaCosa::getTrue();
}