No soy partidario de "hacer ejercicios" (de hecho, es norma del foro no hacer tarea ) pero por mi cuenta va también porque te estaría ayudando poco y nada.

Por eso solo te voy a dar unas pistas.
Primero, necesitaría saber que es exactamente lo que no entiendes.

¿Sabes lo que es una estructura? Si no sabes eso, no puedes hacer el ejercicio. Busca lo que es en cualquier libro de programación en C.

¿Sabes declarar una estructura? Si no sabes eso, no puedes hacer el ejercicio. Busca lo que es en cualquier libro de programación en C.

¿Sabes acceder a cada uno de los campos de una estructura? Si no sabes eso, no puedes hacer el ejercicio. Busca lo que es en cualquier libro de programación en C.

¿Sabes asignar valores a los campos de una estructura? Si no sabes eso, no puedes hacer el ejercicio. Busca lo que es en cualquier libro de programación en C.

Habiendo hecho estos 4 puntos, el problema está resuelto.

PD: Puedes cambiar "en cualquier libro de programación en C" por "Internet" o por "foro.elhacket.net"

De http://es.wikipedia.org/wiki/EOF :

"La interpretación de C como resultado de la operación de lectura en caso de ser EOF es, por lo general, -1."

Así que no estás tan loco

Si, revisa tu algoritmo. El ciclo itera siempre y cuando c sea distinto de EOF.
Por ende, este saldrá del ciclo cuando c sea igual a EOF.
Ahora bien, ya sabes que luego de salir del ciclo, tendrás EOF en la variable c. Lo único que queda por hacer es imprimirla en la pantalla.
Escribe una sentencia que imprima en la pantalla la variable c. Y listo ^^
Saludos!

Lo que estás haciendo con dicha función es ir tomando caracter a caracter de un archivo (en este caso, stdin, el archivo de entrada por defecto; es decir, la consola), y pegándolos (en este caso también en el archivo de salida por defecto, la consola).

Para que te quede un poco más claro, si utilizas este algoritmo y getchar() en un archivo de texto plano (.txt por ejemplo), de cualquier lugar de tu computadora, copiará el contenido del archivo de texto y lo pegará en la pantalla (puede ser otro archivo de texto, o también la consola). Pero para aprender esto necesitarás saber manejo de archivos (no recuerdo si hay algo relacionado en el libro de K&R).

Con respecto a tu punto 2). EOF hace referencia a End Of File. Cuando estás leyendo un archivo, y éste termina (por ejemplo, termina de leer todo un texto en el .txt) hay una marca llamada EOF, que le avisa al programa que ese archivo ha llegado a su fin. Este se lee con por ejemplo, getchar() y posee un valor. Cuando llega a ese valor, en el algoritmo que tu escribiste, sale del ciclo, y deja de leer, puesto que sabe que llegó a su fin.

"++" es un operador unario que se aplica a una variable para incrementar en 1 unidad el valor de dicha variable.

"i++" incrementa en 1 el valor de i.

Bueno, es que al desreferenciar dicha variable sin paréntesis estás desreferenciando nodoe->next, y lo que tu quieres desreferenciar es solo nodoe, el cual es un puntero a puntero de struct. Tu quieres hacer: (**nodoe).next == (*nodoe)->next.
Si le quitas los paréntesis, es como hacer *(nodoe->next) lo cual es un error porque no existe ningún campo en la variable (*nodoe) ya que es sólo un puntero a struct (debes desreferenciar solamente nodoe nuevamente para acceder a la struct correspondiente y al campo next en ella).

Espero que se haya entendido!
Salú!

Tienes que usar paréntesis!!!

#include <stdio.h>
#include <stdlib.h>
 
typedef struct listacompleta {
         int dato;
         struct listacompleta *next;
        }lista;
 
 
void add_nod(lista **nodoe, int dato){
 lista *nuevo,*aux;
 nuevo = (lista *) malloc (sizeof(lista));
 nuevo->dato = dato;
 aux = *nodoe;
 if(*nodoe == NULL ){
             nuevo->next = nuevo;
             *nodoe = nuevo;
            } else{
               *nodoe = (*nodoe)->next;
               nuevo->next = aux->next;
               aux->next = nuevo;
              }
}
 
 
 
int main(){
 lista *nodoe;
 nodoe = NULL;
 
 add_nod(&nodoe,8);
 add_nod(&nodoe,2);
 add_nod(&nodoe,3);
 add_nod(&nodoe,5);
 
 system("pause");
 return 0;
 
}

Es exactamente esto que dices.
Discriminante de una sección cónica: "http://es.wikipedia.org/wiki/Discriminante#Discriminante_de_una_secci.C3.B3n_c.C3.B3nica"

No habría que seguir desvirtuando pero... 1 dimension = R = recta real.
2 dimensiones = R^2 = plano. (plano xy genéricamente)
3 dimensiones = R^3 = espacio.

Al menos para mí está bien dicho

Eso no compila. No estás accediendo adecuadamente a la matriz.
La variable disco es un puntero a struct ejemplo, no es la estructura en sí.
Podés acceder utilizando disco->matriz[][].

El utilizar "->" es lo mismo a utilizar (*disco).matriz[][].
Es decir, para acceder a la matriz, primero tenés que desreferenciar el puntero utilizado.

EDIT: Hay otro error. Le estás pasando a la función "llenado" un struct ejemplo, y lo que en realidad espera es un puntero a un struct ejemplo.
Entonces podés hacer dos cosas. Podes modificar el parámetro de la función, borrándole el asterisco para que no espere un puntero (y compilaría):

#include <iostream>
#include <string.h>
using namespace std;
struct ejemplo{
       char matriz[5][5];
       };
void llenado(struct ejemplo *disco)
{
     strcpy(disco->matriz[0],"a"); /*Aqui es donde querria acceder, pero no me deja*/
}
int main(void)
{
    int asd;
    struct ejemplo llamada;
    llenado(&llamada);
    cout<<llamada.matriz[0];
 
    cin>>asd;
}

O podés referenciar el argumento cuando llamás a la función:

#include <iostream>
using namespace std;
struct ejemplo{
       char matriz[5][5];
       };
void llenado(struct ejemplo *disco)
{
     strcpy(disco->matriz[0], "a"); /*Aqui es donde querria acceder, pero no me deja*/
}
int main(void)
{
    int asd;
    struct ejemplo llamada;
    llenado(&llamada);
    cout<<llamada.matriz[0];
 
    cin>>asd;
}