Se pueden tener apuntadores a cualquier tipo de variable.

Para entender perfectamente este desmadre de los apuntadores… aprendete estas reglas magicas:

1.- Un apuntador es una variable que contiene la dirección en memoria de otra variable.

main()
{
    int x = 1;
    int *ap;  //Apuntador que permite
                //ser usado con variables enteras

    ap = &x;  //Se le asigna la direccion
                  //de memoria que alverga el valor 1

    printf("Direccion de el apuntador ap:%x",ap);
}

La consola termina imprimiendonos esto:
Imprime la direccion de el apuntador ap:bf9ed410

2.- Un apuntador puede ser desreferenciado, para accesar a el valor que contiene (a esto se le llama acceso indirecto) esto se logra agregando el * al identificador del apuntador:

main()
{
    int x = 1;
    int *ap;  //Apuntador que permite
                //ser usado con variables enteras

    ap = &x;  //La direccion de memoria de x
                  //se asigna a la direccion de
                 // memoria que alberga el apunt
                 // ador ap

    printf("Valor de el apuntador ap:%d",*ap);
}

La consola termina imprimiendonos esto:
Valor de el apuntador ap :1

3.- C no es muy estricto en la asignación de valores de diferente tipo (entero a apuntador - apuntador a entero). Así que es perfectamente legal (aunque el compilador genera un aviso de cuidado).

main()
{
    int x;
    int y;
    int *ap;

    y = 3;
    ap = y; //Ahora se apunta
	    // a la localidad de
            // memoria 3

    x = ap; //Aqui x recibe el valor
            //3

    printf("Localidad de memoria:%d",x);
}

La consola termina imprimiendonos esto:
Localidad de memoria x :3

4.- No se puede usar un apuntador, si no esta este previamente inicializado
Por lo que:

main()
{
    int *ap;
    *ap = 100;
}

puede generar un error en tiempo de ejecución o presentar un comportamiento errático.

El uso correcto será:

main()
{
    int *ap;
    int x;

    ap = &x;
    *ap = 100;
}

5.- En los apuntadores a estructuras: Se usa la notación p->member

main()
{
     typedef struct {
	char member_1;
	int  member_2;
     } s_type;

     s_type x={'U',2}, *p = &x;

     p->member_1 = 'R'; // Equivale a (*p).member_1 = 'R';

     //Observece como sacamos el contenido de uno de
    // los elementos de la estructura de forma indirecta
     printf("Caracter encontrado:%c",(*p).member_1);
}

Imprime en consola
Caracter encontrado:R
Con estas reglas basica ahora podras comprender la fabulosa Aritmetica de punteros