Mensajes

Así:

Código (cpp) [Seleccionar] Expandir


fprintf(fp,"\tchar *pass = \"%s\";\n", cmb);      /* <-- observa el argumento %s */
fprintf(fp,"\tprintf(\"dame la clave: \");\n");    /* <-- no necesitas el argumento cmb */
fprintf(fp,"\tscanf(\"%%s\", pass);\n");                /* no es &pass, sino simplemente pass */
fprintf(fp, "\twhile ( getchar() != '\\n' );\n" );    /* <-- limpias búfer después de scanf() */
fprintf(fp,"\tif( strcmp( pass, \"%s\") ) exit(1); \n\n", cmb);    /* si el pass no es igual a cmb, salir */


Hay un detalle con scanf(). Esta función requiere un argumento de tipo apuntador al tipo de dato declarado con %d, %s, etc. Si lees un entero, debes pasarle un apuntador a entero, por eso pones el "&". Pero en C las cadenas son técnicamente apuntadores a variables tipo char (el tema de apuntadores en C es delicado, y es algo que debes leer a profundidad cuando tengas tiempo), por eso no requieren "&". Se escribe:

Código (cpp) [Seleccionar] Expandir


scanf(\"%s\", pass);
con "pass" y no "&pass". Por otra parte, el pass es de tipo cadena, lo correcto es declarar como "char *". Luego, a la hora de comparar el pass con el cmb se usa la función strcmp() que devuelve cero si las cadenas son IGUALES, y distinto de cero si son DIFERENTES.

Aquí te mando el programa completo con las correcciones:

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>

int main() {

   FILE *fp;
   char filename[31];          //filename for source code
   char creador[51];       /* <-- cadena para contener el nombre del creador */
   char *cPtr;
   size_t i;

   // starting header of outputted file
   char header[300];

   //all the includes in output file
   char incs[200] = "#include <stdio.h>\n#include <conio.h>\n#include <stdlib.h>\n#include <windows.h>\nint WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,\nPSTR szCmdLine, int iCmdShow)\n{\n\n";

   //end part of output file
   char end[50] = "\treturn 0;\n}";

   //for command
   char cmd[150];

   //para el resto, la clave
   char cmb[350] = "abc566h7Tgfr";

   printf("\t+----------------------------+\n");
   printf("\t|BATCH TO C SOURCE CONVERTER |\n");
   printf("\t|CODED BY SAMARDHWOJ ACHARYA |\n");
   printf("\t+----------------------------+\n");

   printf("Introduce el nombre del creador: ");
   scanf("%s", creador);
   while ( getchar() != '\n' ) /* limpia el caracter ENTER de la entrada estandar */
      ;
   sprintf( header, "\nCodigo creado por %s\n", creador);       /* <-- revisa aqui */

   printf("\nEnter the filename(with .c extension): ");
   scanf("%s",filename);
   while ( getchar() != '\n' )    /* limpia el caracter ENTER de la entrada estandar */
      ;

   fp = fopen(filename,"w");
   if (fp==NULL)
   {
      printf("Some error occurred while opening file");
      getchar();
      exit(1);
   }
   else
   {
      fprintf(fp,"%s%s",header,incs);

      fprintf(fp,"\tchar *pass = \"%s\";\n", cmb);      /* <-- observa el argumento %s */
      fprintf(fp,"\tprintf(\"dame la clave: \");\n");    /* <-- no necesitas el argumento cmb */
      fprintf(fp,"\tscanf(\"%%s\", pass);\n");                /* no es &pass, sino simplemente pass */
      fprintf(fp, "\twhile ( getchar() != '\\n' );\n" );    /* <-- limpias búfer después de scanf() */
      fprintf(fp,"\tif( strcmp( pass, \"%s\") ) exit(1); \n\n", cmb);     /* si el pass no es igual a cmb, salir */

      printf("\nNow start entering DOS commands: \n");
      printf("When finished, type 'end' for the end of commands\n");

      printf("\nStart:\n\n");

      fgets( cmd, 150, stdin );
      if ( ( cPtr = strchr( cmd, '\n' ) ) != NULL ) *cPtr = '\0';

      while ( strcmp( cmd, "end" ) )
      {
         fprintf(fp,"\tsystem(\"%s\");\n",cmd);
         fgets( cmd, 150, stdin );
         if ( ( cPtr = strchr( cmd, '\n' ) ) != NULL ) *cPtr = '\0';
      }
      fprintf(fp,"\tprintf(\"\\n\");");

      fprintf(fp,"\n%s",end);

      printf("\n\nFile successfully created");
      printf("\nNow compile it with any C compiler");
      printf("\nThanks for using this little app");
      fclose(fp);
   }
   getchar();
}

Yo probé para generar un script con los comandos "dir" y "cd .." que se active con la contraseña abc566h7Tgfr. He aquí uan vista de mi consola cuando estaba ejecutando el programa (en Linux)

Código [Seleccionar] Expandir


yoel@yoel-pc:~/Documentos/C/test$ ./test
+----------------------------+
|BATCH TO C SOURCE CONVERTER |
|CODED BY SAMARDHWOJ ACHARYA |
+----------------------------+
Introduce el nombre del creador: yoel

Enter the filename(with .c extension): script.c

Now start entering DOS commands:
When finished, type 'end' for the end of commands

Start:

dir
cd..
end


File successfully created
Now compile it with any C compiler
Thanks for using this little app


y ve el fichero script.c que me generó:

Código [Seleccionar] Expandir


Codigo creado por yoel
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <windows.h>
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
PSTR szCmdLine, int iCmdShow)
{

char *pass = "abc566h7Tgfr";
printf("dame la clave: ");
scanf("%s", pass);
while ( getchar() != '\n' );
if( strcmp( pass, "abc566h7Tgfr") ) exit(1);

system("dir ");
system("cd..");
printf("\n");
return 0;
}


Si compilaras este source (para Windows), te daría un ejecutable que te pide contraseña y luego de validar ejecutaría en consola los comandos dir y cd ... Era ese el resultado que querías lograr ? 

************* CONTINUANDO EL TEMA *****************

Hay otros detalle dignos de mencionar. Si realmente te apasiona aprender programación C, sigue leyendo, de lo contrario no lo hagas porque te voy a aburrir 

Observa que modifiqué ligeramente la estrcutura de control del while() por una forma más práctica:

Código (cpp) [Seleccionar] Expandir


while ( strcmp( cmd, "end" ) )
      {
         fprintf(fp,"\tsystem(\"%s\");\n",cmd);
         gets(cmd );
         printf( "cmd is: %s\n", cmd );
      }

así, en vez de poner while(1), y luego poner una condición de parada con break dentro del bucle, pusimos la condición de parada como condición de ejecución del propio while, que es por cierto donde debe ir. Los puristas de la programación estructurada aconsejan recurrir lo menos posible a sentencias como break o continue, a menos que a cambio vayas a aobtener una sustancial mejora del rendimiento, que no es el caso.

A propósito de gets(). Esta función se considera potencialmente peligrosa porque corre el riesgo de sobrepasar la longitud del array donde estás almacenando los caracteres leídos. Es mejor usar getline() de C++, o la misma fgets() de C. Esta última permite especificar la longitud máxima del arreglo leído. Ejemplo, si la longitud de cmd es 150 (lo cual significa que al descontar el nulo de terminación habrá espacio para 149 caracteres), entonces puedes usar

Código (cpp) [Seleccionar] Expandir


fgets( cmd, 150, stdin );

con lo cual serán leídos no más de 149 caracteres de la entrada estándar (teclado). El problema con fgets() es que esta función sí pasa el ENTER al final de la cadena, lo que puede generar un efecto indeseado. Para eliminarlo puedes usar algo como:

Código (cpp) [Seleccionar] Expandir


size_t i;

fgets( cmd, 150, stdin );
for ( i = 0; cmd[i] != '\0'; i++ )
    if ( cmd[i] == '\n' ) cmd[i] = '\0';
(el "size_t i" va una sola vez en el apartado de declaración de variables del main()). Otra manera sería

Código (cpp) [Seleccionar] Expandir


char *cPtr;

fgets( cmd, 150, stdin );
if ( ( cPtr = strchr( cmd, '\n' ) ) != NULL ) *cPtr = '\0';
que reemplaza la primera ocurrencia del carácter '\n' en cmd por el nulo de terminación '\0'.

Amigo sabeeee,

Luce interesante este ejemplo que has escogido para practicar, usa la función system() para "convertir" un script de comandos de DOS en un código fuente compilable de c. ¿Sabes que system() lo que hace es recurrir al procesador de comandos del sistema operadivo para evaluar una orden de comandos determinada? Por ejemplo, system("dir") ejecuta la orden de MSDOS "dir", la cual muestra el directorio actual, en Windows. Tambièn me doy cuenta por el "header" que genera en el archivo .c producido que es específico para Windows.

Mis observaciones. En primer lugar, "creador" es un string o cadena de caracteres. Debe ser declarado como tal:

Código [Seleccionar] Expandir


char creador[51];

¿por qué 51? Pues, 50 caracteres más el carácter nulo de terminación de la cadena que se debe incluir. Luego, una forma de concatenar la cadena header + la cadena literal "Codigo creado por " + la cadena creador, puede ser:

Código [Seleccionar] Expandir


sprintf( header, "\nCodigo creado por %s\n", creador);


Finalment un pequeño detalle que quizá no conocías del comportamiento de la función scanf( str ). Esta función lee una cadena de la entrada estándar (teclado) y la copia en la cadena argumento str. Por ejemplo:

scanf("%s", creador);

lee de la entrada estándar y copia el valor leído en la cadena creador. El detalle es que el carácter ENTER con que finalizar la cadena NO es copiado a creador, pero SÍ permanece en el "búfer" de entrada del teclado. Debes limpiar este carácter con la sentencia:

Código [Seleccionar] Expandir


while ( getchar() != '\n' ) /* limpia el caracter ENTER de la entrada estandar */
     ;

(no olvides el punto y coma al final). Si no lo haces, entonces dicho carácter será leído con la siguiente llamada de scanf(), dando como resultado que se lea una cadena nula la próxima vex, lo que no queremos que ocurra.

Finalmente el código con las modificaciones, y por cierto que no es necesariamente para g++, también puede ser compilado con gcc puesto que está escrito en C, no en C++.

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>

int main() {

  FILE *fp;
  char filename[31];          //filename for source code
  char creador[51];       /* <-- cadena para contener el nombre del creador */

  // starting header of outputted file
  char header[300];

  //all the includes in output file
  char incs[200] = "#include <stdio.h>\n#include <conio.h>\n#include <stdlib.h>\n#include <windows.h>\nint WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,\nPSTR szCmdLine, int iCmdShow)\n{\n\n";

  //end part of output file
  char end[50] = "\treturn 0;\n}";

  //for command
  char cmd[150];

  printf("\t+----------------------------+\n");
  printf("\t|BATCH TO C SOURCE CONVERTER |\n");
  printf("\t|CODED BY SAMARDHWOJ ACHARYA |\n");
  printf("\t+----------------------------+\n");

  printf("Introduce el nombre del creador: ");
  scanf("%s", creador);
  while ( getchar() != '\n' ) /* limpia el caracter ENTER de la entrada estandar */
     ;

  /* revisa aqui */
  sprintf( header, "\nCodigo creado por %s\n", creador);

  printf("\nEnter the filename(with .c extension): ");
  scanf("%s",filename);
  while ( getchar() != '\n' )    /* limpia el caracter ENTER de la entrada estandar */
     ;

  fp = fopen(filename,"w");
  if (fp==NULL)
  {
     printf("Some error occurred while opening file");
     getchar();
     exit(1);
  }
  else
  {
     fprintf(fp,"%s%s",header,incs);

     printf("\nNow start entering DOS commands: \n");
     printf("When finished, type 'end' for the end of commands\n");

     printf("\nStart:\n\n");

     gets( cmd );

     while ( strcmp( cmd, "end" ) )
     {
        fprintf(fp,"\tsystem(\"%s\");\n",cmd);
        gets(cmd );
     }
     fprintf(fp,"\tprintf(\"\\n\");");

     fprintf(fp,"\n%s",end);

     printf("\n\nFile successfully created");
     printf("\nNow compile it with any C compiler");
     printf("\nThanks for using this little app");
     fclose(fp);
  }
  getchar();
}

Hula chiue. Hay varios aspectos que tratar. En primer lugar, recuerda que la instrucción getline(f,n); lee una línea del fichero y la copia en el string "n", luego es el contenido de este string (y no del fichero "f") el que pasas a los campos de la estructura. Tambiés debes tener en cuenta (o al menos yo no pude dar con una manera más sencilla de hacerlo) que hay campos tipo "int", "char" y "string", por lo que debes hacer la conversión explícita de tipo según el caso:

Código [Seleccionar] Expandir


v[i].identificador = atoi(n.c_str());
...
v[i].nombre = n;
...
v[i].direccion = n;


etc. Por último y muy importante lo que te recalcó Orubatosu, no puedes leer todo el fichero y luego copiar los valores a la estructura, pues en ese caso estarías pasando sólo los valores de la última línea del fichero. Debes leer línea por línea, y distinguir lo que se debe leer si es la primera línea, la segunda, la tercera, etc.

Para ello usamos el operador "%" de resto de la división entera. Analiza la estructura de este fichero con sus números de línea

1. ---| 1012 |---
2. 24532333 X
3. La taberna vasca
4. Avda. Pio XII
5. taberna.vasca@hotmail.com
6. Valencia
7. ---| 1230 |---
8. 22345123 P
9. Cafes Valiente
10. Avda. Campanar
11. cafes.valiente@hotmail.com
12. Valencia
13. ---| 1455 |---
14. 20234561 T
15. Bier Winkeln
16. Avda. Campanar
17. Bier.Winklen@hotmail.com
18. Valencia


Aquellas lìneas con los Nros. 1., 7., 13., ..., o sea aquella cuyo resto de dividir por 6 sea 1, corresponden al identificador. Las líneas 2., 8., 14., etc, cuyo resto de dividir por 6 sea 2 corresponden al par "num-letra", y así sucesivamente. Ten en cuenta que esta línea Nro. 2 en particular debe ser dividida en dos sub-strings para extraer el número (tipo num*) y la letra (tipo (char)).

Finalmente, no veo definido el tipo de dato "VecClientes", pero supongo que es un arreglo de struct cliente. Aquí el código de mi propuesta:

Código (cpp) [Seleccionar] Expandir


#include <cstdlib>
#include <iostream>
#include <fstream>
#include <string>

using namespace std;

struct CIF {
   int num;
   char letra;
};

struct cliente {
   int identificador;
   CIF c;
   string nombre;
   string direccion;
   string correo;
   string ciudad;
};
typedef struct cliente * VecClientes;   /* <--- Yo puse esto */

void FncLeerClientesFich(ifstream &f,VecClientes v, int &tam);


int main ()
{
   string cadena;
   ifstream f("datos1.txt");
   struct cliente v[100];
   int tam;

   FncLeerClientesFich(f, v, tam);

   /* En este codigo de prueba vamos a imprimir los datos
    * que ha cargado del archivo
    */
   for ( int i = 0; i < tam; i++ ) {
      cout << v[i].identificador << endl;
      cout << v[i].c.num << " | " << v[i].c.letra << endl;
      cout << v[i].nombre << endl;
      cout << v[i].direccion << endl;
      cout << v[i].correo << endl;
      cout << v[i].ciudad << endl;
      cout << "------------------------" << endl;
   }

   f.close();

   return 0;
}

void FncLeerClientesFich(ifstream &f,VecClientes v, int &tam) {

   int i = 0;
   string n;
   string n1, n2; /* <-- esto es nuevo */
   int l = 0;
   while (!f.eof()) {
      getline(f,n);
      l++;

      /* 1ra linea */
      if ( l%6 == 1 )
         v[i].identificador = atoi(n.c_str());
      /* 2da linea */
      if ( l%6 == 2 ) {
         /* aqui dividimos el string en dos partes, por la cadena
          * separadora " "
          */
         size_t ind = n.find(" ");
         n1 = n.substr(0, ind);
         n2 = n.substr(ind + 1, n.length());
         v[i].c.num = atoi( n1.c_str() );
         v[i].c.letra = n2[0];
      }
      /* 3ra linea */
      if ( l%6 == 3 )
         v[i].nombre = n;
      /* 4ta linea */
      if ( l%6 == 4 )
         v[i].direccion = n;
      /* 5ta linea */
      if ( l%6 == 5 )
         v[i].correo = n;
      /* 6ta linea */
      if ( l%6 == 0 ) {
         v[i].ciudad = n;

         /* incrementa campo cada 6 lineas leidas del fichero */
         i++;
      }
   }
   tam = i;

   return;
}


y aquì puedes ver la salida del programa, donde le hice imprimir lo que ha leido del archivo:

Código [Seleccionar] Expandir


1012
24532333 | X
La taberna vasca
Avda. Pio XII
taberna.vasca@hotmail.com
Valencia
------------------------
1230
22345123 | P
Cafes Valiente
Avda. Campanar
cafes.valiente@hotmail.com
Valencia
------------------------
1455
20234561 | T
Bier Winkeln
Avda. Campanar
Bier.Winklen@hotmail.com
Valencia
------------------------
1875
12356355 | R
Tapioca. Comidad para llevar.
Avda. Tres Forques
Tapioca@hotmail.com
Valencia


Por cierto, el fichero "datos1.txt" contiene la información que dices, de donde tomar los datos.

Enjoy it !!!

La idea debe ser buscar recursivamente, por ensayo y error, hasta encontrar el punto final de la ruta.

Te paras en el primer nodo, y luego entre todos los (n-1) nodos restantes hay algunos que se conectan con el primero (y otros que quizá no). Digamos que hay M1 nodos que se conectan con el primero, entonces debes explorar todas estas M1 posibilidades. Cada un de ellos a su vez genera nuevas posibilidades de conectarse con un tercer nodo y así sucesivamente.

Pero a mí esta idea se me va pareciendo más a un árbol de búsqueda de múltiples ramas, que a una cola ....

Es cuestión de hacer un algoritmo en papel, ejecutarlo "a mano", y luego pasarlo a código de programación. Al final, tendrás un cierto número de soluciones al problema (suponiendo que hay una al menos), y elegirás la trayectoria con menos nodos como la más corta.

Voy a ver si al final de este día te preparo algo mejor y te lo envío. Ten en cuenta también que quizá tenemos zonas horarias diferentes tú y yo.

Encantado pues 

Pues en ese caso no hay problema, pues getchar() requiere <stdio.h>, que ya la tienes.

Ok, entiendo. Bueno yo humildemente hubiera trabajado la parte de convertir a chuck_norris de una manera diferente y creo que más breve. Tomo el array binario y agarro el primer digito. Luego reviso el segundo, tercero, etc, y así hasta encontrar uno diferente al primero. De esa manera delimito un primer bloque y además llevo la cuenta de la cantidad de dígitos que posee.

Luego, tomo como dígito de prueba el que encontré que era diferente al primero (justo donde se terminó el primer bloque), y repito el proceso para ver cuántos son iguales a este de prueba. Repitiendo el proceso logro convertir toda la secuencia.

Por ejemplo, cuando paso el carácter 'A' (ASCII 65), su binario es '1000001', que el programa me convierte a:

   0 0 00 00000 0 0

que según creo es lo que se quiere, ¿no?

Un detalle, reutilizar apropiadamente el espacio de variables y no desperdiciar memoria, empleé la variable 'letra' para representar los dígitos del binario.

El programa, con mi modificación propuesta, es:

Código (cpp) [Seleccionar] Expandir


#include <stdlib.h>
#include <stdio.h>
#include <string.h>

/**
* Auto-generated code below aims at helping you parse
* the standard input according to the problem statement.
**/


int main()
{
    char MESSAGE[100];
    fgets(MESSAGE,100,stdin);
    int size=strlen(MESSAGE);
    int letra;
    int Ascii;
    int binario[50];
    int temp;
    int contador=0;
    int reverso[700];
    int indice=0;
    char chuck_norris[700];
    int unocero=0;
    int unomas=0;
    short bloque1=0;

    // Write an action using printf(). DON'T FORGET THE TRAILING \n
    // To debug: fprintf(stderr, "Debug messages...\n");
    //---------------------------

    *chuck_norris = '\0'; /* inicializa cadena vacia */
    for (int a=0; a<size; a++) {
        if (MESSAGE[a]!='\0' && MESSAGE[a]!='\n')
        {
            letra=MESSAGE[a];//tomo el valor ascii
            if (letra<=64)
            {
                reverso[0]=0;
                unomas=1; //si es menor a el codigo ascii 64 se le pone un cero al comienzo eso es uno mas
            }
            //----------------------------
            contador=0;
            temp=letra;

            //convierto el numero a binario
            while (temp>0) {
                binario[contador]=(temp%2);
                temp=temp/2;
                contador++;
            }
            int conta3=contador-1; //contador es el largo de binario
            contador=contador+unomas;//si es menor a 64 se le pone un cero al comienzo eso es uno mas

            for (int inv=0; inv<contador; inv++)
            {
                reverso[inv+unomas]=binario[conta3];//  binario estan los numeros al reves asi que le doy la vuelta
                conta3--;
            }

            /* imprimimos en binario para ver el resultado */
            printf( "binario: " );
            for ( int i = 0; i < contador; i++ )
                putchar( '0' + reverso[i] );
            printf("\n");

            //ahora lo pasare a el codigo chuck norris

            /* ============= MI PROPUESTA DE CHUCK NORRIS =======================
             * --- Humildemente, Yoel.-
            */
            int i = 0;
            /* convertiremos el binario reverso a chuck norris */
            while ( i < contador ) {
                /* NOTA: al final de este while, la variable n contendra la cantidad de veces que se repite
                 * letra en el bloque actual
                 */
                int n = 0;
                letra = reverso[i];
                while ( i < contador && reverso[i] == letra ) {
                    n++;
                    i++;
                }

                /* ahora transcribe a la cadena chuck_norris apropiadamente segun el caso */
                if ( letra == 1 )
                    strcat( chuck_norris, "0 ");
                else if ( letra == 0 )
                    strcat( chuck_norris, "00 ");

                while ( --n >= 0 ) {
                    strcat( chuck_norris, "0" );
                }
                /* espacio para delimitar el fin de bloque */
                strcat( chuck_norris, " ");
            }
            strcat( chuck_norris, "| ");
            /*=============== FIN =================*/
        }
    }

#if 0
    for (int final=0; final<contador; final++) {
        //si bloque1=1 entonces estamos en el segundo bloque y se le agrega un cero si continua siendo el mismo del primer bloque unocero
        if (bloque1==1) {
            if (reverso[final]==unocero)
            {
                chuck_norris[indice]='0';
                indice++;
            }
            else
            {
                chuck_norris[indice]=' ';
                indice++;
                bloque1=0;
            }
        }
        //------------------------------------
        if (reverso[final]==1 && bloque1==0) //si estamos en el primer bloque y es un uno escribe en la respuesta 0 0
        {
            chuck_norris[indice]='0';
            indice++;
            chuck_norris[indice]=' ';
            indice++;
            chuck_norris[indice]='0';
            indice++;
            bloque1=1; // cambiamos de bloque
            unocero=1; //si cambia este numero es que se acabaron los unos repetidos
        }
        else if (reverso[final]==0 && bloque1==0) //si estamos en el primer bloque y es un cero escribe en la respuesta 00 0
        {
            chuck_norris[indice]='0';
            indice++;
            chuck_norris[indice]='0';
            indice++;
            chuck_norris[indice]=' ';
            indice++;
            chuck_norris[indice]='0';
            indice++;
            bloque1=1;// cambiamos de bloque
            unocero=0;//si cambia este numero es que se acabaron los unos repetidos
        }
        //----------------------
    }
    chuck_norris[indice]='\0';// se le agrega el final de la cadena
#endif

    printf("%s\n",chuck_norris);//escribe la respuesta

    return 0;
}

Te muestro la salida generada con la cadena de entrada "ABC":


ABC
binario: 1000001
binario: 1000010
binario: 1000011
0 0 00 00000 0 0 | 0 0 00 0000 0 0 00 0 | 0 0 00 0000 0 00 |


donde he usado el separador '|' para distinguir a la vista un código del otro (aunque no se si realmente necesitas eso).

Revisa y me comentas!!! 

Hola daryo. Estoy trabajando en tu proyecto pero por favor explícame que significa la parte de:

unomas=1;  //si es menor a el codigo ascii 64 se le pone un cero al comienzo eso es uno mas

???

Buenos días TheSocker, bienvenido al apasionante mundo de C.

Como T.Collins, los arrays en C comienzan en la posición 0. Y yo añadiría otros pequeños detalles. Primero, debes saber que la función system() invoca una llamda al sistema operativo, por lo tanto es dependiente del sistema de comandos de tu SO. Esto es, corre el riesgo de que tu programa no "corra" igual en un SO que en otro. Por eso yo recomiendo usar getchar() que es una función estándar (se ejecuta igual en cualquier plataforma) y realiza casi la misma función: esperar una pulsación de tecla de parte del usuario.

Otro detalle, en la función leer_vector() debes pasar a scanf la posición (esto es, la dirección de memoria) del elemento específico del array donde copiar el valor leído. Por eso:

Código (cpp) [Seleccionar] Expandir


scanf("%d", &v[i] );

Como sabrás, el operador "&" devuelve la dirección del elemento apuntado, en este caso la dirección de v[ i].

Y finalmente en el main(), donde mandas imprimir la media del vector, no puedes pasar como argumento simplemente el nombre de la función, sino que debes poner "media_vector(vector,dim)" con los argumentos donde media_vector() debe ser evaluada. Te quedaría:

Código (cpp) [Seleccionar] Expandir


printf("\n\nMedia: %f", media_vector(vector,dim) );

Esto es anidamiento de funciones; el valor de retorno de una función pasado como argumento de otra. Finalmente el código te quedaría:

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
#define DIM 100

void leer_vector(int *, int);
float media_vector (int *, int);
void escribir_vector(int *, int);

int main(int argc, char *argv[]) {

  int dim;
  int vector[DIM];

  printf("Introduce la dimension del vector: ");
  scanf("%d",&dim);

  leer_vector(vector,dim);

  printf("\n\n");

  escribir_vector(vector,dim);

  media_vector(vector,dim);

  printf("\n\nMedia: %f", media_vector(vector,dim) ); /* <-- revisa aqui */

  printf("\n\n");

  //system("PAUSE"); /* <-- solo para Windows */
  getchar(); /* <-- es mas compatible */
  return 0;
}


float media_vector (int *v, int dim) {

  int i;
  float media;
  media = 0;
  for (i=0; i<dim; i++) {
     media = media + v[i];
  }

  return media/dim;
}


void leer_vector(int *v, int dim) {
  int i;
  for (i=0; i<dim; i++) {
     printf("\nElemento (%d): ", i);
     scanf("%d", &v[i] );
  }
}

void escribir_vector(int *v, int dim) {
  int i;
  for (i=0; i<dim; i++) {
     printf("%4d\t", v[i] );
  }
}

Un ejemplo de corrida del programa:


Introduce la dimension del vector: 4

Elemento (0): 5

Elemento (1): 8

Elemento (2): 4

Elemento (3): 2


  5      8      4      2   

Media: 4.750000