Apendice 1 C++

Respondiendo una pregunta en Yahoo.
Para almacenar datos primero tenes que contar con una estructura de datos, como un vector de string que en c será una matriz de caracteres, luego por el indice del vector lo relacionaras con otros datos correspondientes al mismo registro, sea otro u otros vectores de strings, vectores de enteros vectores de floats etc.
Estructura de datos
vector de strings
vector de strings
vector de enteros
vector de lo que se necesite
otros vectores
se inicia un bucle for desde 0 hasta la cantidad de elementos de cada vector ( n)
Ingerse el nombre de la persona --> al primer vector
Ingrese el apellido de esa persona --> al segundo vector
ingrese la edad de la persona --> al vector de enteros
ingrese el dato que necesite --> al vector de datos que se necesiten
--------
ingrese este ultimo dato --> al vector de ultimos datos
fin de la crga de este registro, se incrementa en un el indice de los vectores
y se reiicia el procedimiento para el segundo registro
Se pone una condicion como que si el primer dato es un string nulo, se cierra el proceso de carga antes de llegar a "n", si no se pone esta condicion el proceso se repetira hasta tener todos los datos cargados.

Para salvaguardar los datos, y no tener que volver a cargarlos, será conveniente tener un archivo de disco ( o varios) que guarden los vectores, y luego al iniciar de nuevo el programa, recuperen esos datos y los carguen en forma automatica a los vectores.

Para continuar con la carga de datos, se inicia un for que se detenga cuando el primer vector tenga string nulo, y conservando ese valor del indice, se inicia a partir de alli el proceso de carga de datos
se inicia un bucle for desde "ese valor" hasta la cantidad de elementos de cada vector ( n).

Para buscar un nombre dentro de un string, se puede hacerlo mediante la comparacion strcmp que devuelde algo distinto de 0 si no coinciden y 0 si son iguales, para lo cual, deberemos cargar en un string el nombre a buscar y recorrer los nombres desde el vector 0 hasta el n, si llega al n y no encontro nada, entonces el nombre no está, si llega a un string igual, muestra el resultado de ese y los demas datos junto con el indice donde lo encontro, lo cual nos dará un listado de coincidencias, que nos servirá para saber si esa persona esta anotada, al verificar si corresponden los dems datos.

Otro procedimiento mas rápido para la busqueda, es filtrar por las primeras letras del apellido, para lo cual no es necesario usar el strcmp sino fijar la primera letra y la segunda por ejemplo, y recooriendo los vactores en manera similar a la anterior, si el vector apellido[0][i] == 'primera letra' && apellido[1][i]== 'segunda letra'  (notese que en la comparacion usé comilla simple par la comparacion de un caracter) entonces muestro el resto del registro y el indice, para saber si se trata de nuestro amigo, y luego si existe en el listado es que ya está en la posicion del indice i mostrado.

Ahora, como esto de los vectores funciona, pero en medio enredado para programar, y tambien para guardar en un archivo de disco, C ha provisto de una estructura de datos, en C es UNION en C++ son los STRUCT
este tipo de datos estan compuestos por ese conjunto de vectores, como si fuera un unico elemento de un vector
struct gente{
char ape[30];
char name[30];
int edad;
char mail[50];
float saldo;
} amigo[200];
de esta manera creo una estructura para registrar 200 amigos y sus datos, el nombre del tipo de dato declarado es gente, amigo es un vector de ese tipo de datos de 200 elementos (esto es como funcionan las clase y los objetos, la declaracion es una clase, pero cuando se crea una instancia de la clase recien es un objeto)
A su vez, todo esto puede ser guardado como un solo bloque, y recuperado del disco en un solo bloque en forma sencilla
File *arch;
if((arch=fopen("DATOS.DAT","r+"))==NULL)
{
printf("ERROR; NO SE PUDO ABRIR EL ARCHIVO\n");
getchar();
arch=fopen("DATOS.DAT","w+");
printf("CREADO EL ARCHIVO\n");
exit(1);//termina el programa devolviendo al sistema un error 1
}
else
{
fread(&amigo,sizeof(amigo),1,arch);
fclose(arch);
}

/*ya tenemos el struct cargado con los datos del archivo, si el archivo no existe indicará error, por lo que habra que crearlo para que lo encuentre, si es la primera vez que se ejecuta. Una vez abierto el archivo sin error, se cargan los datos o se busca como en el caso de los vectores y una vez terminada la carga se guarda
arch=fopen("DATOS.DAT","w+");
fwrite(&amigo,sizeof(amigo),1,arch);
fclose(arch);

Espero que puedas llevar a cabo tu proyecto

strcmp() de la libreria string.h
lo demas de la libreria stdio.h
 ▄▄▄▄▄▄▄▄▄▄
   STRING.H
  ▀▀▀▀▀▀▀▀▀
  Functions
  ▀▀▀▀▀▀▀▀▀
   _fmemccpy    _fmemchr     _fmemcmp     _fmemcpy     _fmemicmp
   _fmemset     _fstrcat     _fstrchr     _fstrcmp     _fstrcpy
   _fstrcspn    _fstrdup     _fstricmp    _fstrlen     _fstrlwr
   _fstrncat    _fstrncmp    _fstrnicmp   _fstrncpy    _fstrnset
   _fstrpbrk    _fstrrchr    _fstrrev     _fstrset     _fstrspn
   _fstrstr     _fstrtok     _fstrupr     memccpy      memchr
   memcmp       memcpy       memicmp      memmove      memset
   movedata     movmem       setmem       stpcpy       strcat
   strchr       strcmp       strcmpi      strcpy       strcspn
   strdup       _strerror    strerror     stricmp      strlen
   strlwr       strncat      strncmp      strncmpi     strncpy
   strnicmp     strnset      strpbrk      strrchr      strrev
   strset       strspn       strstr       strtok       strxfrm
   strupr
 ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
 ¦_fstricmp, _fstrcmp,      Ì      <STRING.H>
 ¦strcmp, strcmpi, stricmp  Ì
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
  ■ _fstrcmp and strcmp compare two strings
  ■ strcmpi (a macro) compares two strings without case sensitivity
  ■ _fstricmp and stricmp compare two strings without case sensitivity

 Declaration:
  ■ int strcmp(const char *s1, const char*s2);
  ■ int strcmpi(const char *s1, const char *s2)
  ■ int stricmp(const char *s1, const char *s2);
  ■ int far _fstrcmp(const char far *s1, const char far *s2);
  ■ int far _fstricmp(const char far *s1, const char far *s2);

 Remarks:
■ strcmp performs an unsigned comparison of s1 to s2. _fstrcmp is the far
version.

■ strcmpi (implemented as a macro that calls stricmp) performs an unsigned
comparison of s1 to s2, without case sensitivity.

■ stricmp performs an unsigned comparison of s1 to s2, without case
sensitivity. _fstricmp is the far version.

The string comparison starts with the first character in each string and
continues with subsequent characters until the corresponding characters
differ or until the end of the strings is reached.

To use strcmpi, you must include STRING.H. This macro is provided for
compatibility with other C compilers.
El taductor dice:
 ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
  | _fstrnicmp, _fstrncmp, Strncmp      <String. H>
  | Strncmpi, arranque strnicmp
  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
   ■ _fstrncmp y strncmp Comparar porciones de dos cadenas
   ■ strncmpi (una macro) Compara porciones de dos cadenas,
     sin mayúsculas y minúsculas
   ■ _fstrnicmp y strnicmp Comparar porciones de dos cadenas,
     sin mayúsculas y minúsculas

  Declaración:
   ■ int strncmp (const char * s1, const char * s2, size_t maxlen);
   ■ int strncmpi (const char * s1, const char * s2, size_t maxlen);
   ■ int strnicmp (const char * s1, const char * s2, size_t maxlen);
   ■ _fstrncmp int impresión (const char * s1 ahora, const char * s2 impresión,
       size_t maxlen);
   ■ _fstrnicmp int impresión (const char * s1 ahora, const char * s2 impresión,
       size_t maxlen);

  observaciones:
 Cada una de estas rutinas Compara s1 a s2, mirando a no más de maxlen
 Personajes.

 ■ strncmp y _fstrncmp performaces una comparación sin signo de s1 a s2.

 ■ strncmpi (implementado como una macro que llama strnicmp) realiza una
 comparación de s1 a s2, sin mayúsculas y minúsculas.

 ■ strnicmp y _fstrnicmp realiza una comparación de s1 a s2, sin
 diferenciar entre mayúsculas y minúsculas.

Vemos ahora otra libreia que usamos y sus funciones

 ▄▄▄▄▄▄▄▄▄
  STDIO.H
 ▀▀▀▀▀▀▀▀▀
 Functions
 ▀▀▀▀▀▀▀▀▀
  clearerr    fclose      fcloseall   fdopen      feof        ferror
  fflush      fgetc       fgetchar    fgetpos     fgets       fileno
  flushall    fopen       fprintf     fputc       fputchar    fputs
  fread       freopen     fscanf      fseek       fsetpos     ftell
  fwrite      getc        getchar     gets        getw        perror
  printf      putc        putchar     puts        putw        remove
  rename      rewind      rmtmp       scanf       setbuf      setvbuf
  sprintf     sscanf      strerror    _strerror   tempnam     tmpfile
  tmpnam      ungetc      unlink      vfprintf    vfscanf     vprintf
  vscanf      vsprintf    vsscanf

 ▄▄▄▄▄▄▄▄
 ¦fwriteÌ                           <STDIO.H>
 ▀▀▀▀▀▀▀▀
 Writes to a stream

 Declaration:
   size_t fwrite(const void *ptr, size_t size, size_t n, FILE*stream);

 Remarks:
fwrite appends a specified number of equal-sized data items to an output
file.

 Argument│ What It Is/Does
 ════════Ï═══════════════════════════════════════════════════════
  ptr       │ Pointer to any object; the data written begins at ptr
  size     │ Length of each item of data
  n         │ Number of data items to be appended
  stream │ Specifies output file

The total number of bytes written is
  (n * size)

 Return Value:
  ■ On success, returns the number of items (not bytes) actually written.
  ■ On error, returns a short count.


 Ì▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀¦
 Ì fdopen, fopen, freopen, _fsopen ¦<STDIO.H>
 Ì▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄¦

  ■ fdopen associates a stream with a file handle
  ■ fopen opens a stream
  ■ freopen associates a new file with an open stream
  ■ _fsopen opens a stream with file sharing

 Declaration:
  ■ FILE *fdopen(int handle, char *type);
  ■ FILE *fopen(const char *filename, const char *mode);
  ■ FILE *freopen(const char *filename, const char *mode, FILE *stream);
  ■ _fsopen:
      #include <stdio.h>
      #include <share.h>
      FILE *_fsopen(const char *filename, const char *mode, int shflg);

 Remarks:
■ fdopen associates a stream with a file handle obtained from creat, dup,
dup2, or open.

■ fopen and _fsopen open a file and associate a stream with it. Both
functions return a pointer that identifies the stream in subsequent
operations.

■ freopen substitutes a file in place of the open stream and closes the
stream, regardless of whether the open succeeds. freopen is useful for
changing the file attached to stdin, stdout, or stderr.

  Argument│  Function          │ What Argument Is/Does
 ═════════Ï════════════════Ï════════════════════════════════════════════════
  handle     │ fdopen              │ File handle from creat, dup, dup2, or open
  type         │ fdopen              │ Type of the stream; must match the mode of
                 │                          │ the open handle.
 ──────┼─────────┼────────────────────────────────────────────────
  filename │ fopen, _fsopen  │ File that the functions open
                 │ freopen             │ File substituted in place of the open stream
 ─────┼──────────┼────────────────────────────────────────────────
  mode    │ fopen, freopen,    │ Mode string: defines the mode of the opened
               │ and _fsopen        │ file (r, w, a, r+, w+, a+, etc.)
 ─────┼──────────┼────────────────────────────────────────────────
  stream  │ freopen               │ Open stream, substituted by filename
  shflag   │ _fsopen               │ Specifies the type of file sharing allowed on
              │                             │ filename.

Symbolic constants for shflag are defined in SHARE.H. The file-sharing flags
are ignored if the DOS SHARE command has not been run.

When a file is opened for update, both input and output can be done on the
resulting stream. However:
 ■ output can't be directly followed by input
   without an intervening fseek or rewind
 ■ input can't be directly followed by output
   without an intervening fseek or rewind, or
   an input that encounters end-of-file

 Return Value:
  ■ On success,
  ■ fdopen, fopen, and _fsopen return a
    pointer to the newly opened stream
  ■ freopen returns the argument stream
  ■ On error, these functions return null

  fopen example
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

 /* Program to create backup of the AUTOEXEC.BAT file */

 #include <stdio.h>

 int main(void)
 {
    FILE *in, *out;

    if ((in = fopen("\\AUTOEXEC.BAT", "rt"))
        == NULL)
    {
       fprintf(stderr, "Cannot open input file.\n");
       return 1;
    }

    if ((out = fopen("\\AUTOEXEC.BAK", "wt"))
        == NULL)
    {
       fprintf(stderr, "Cannot open output file.\n");
       return 1;
    }

    while (!feof(in))
       fputc(fgetc(in), out);

    fclose(in);
    fclose(out);
    return 0;
 }

Esto es una copia parcial de la ayuda de Turbo C++ de Borland version 3 e inferiores, el programa esta a disposicion de quien quiera bajarlo para poder contar con esta ayuda, claro que hay que saber un poco de inglés

http://www.4shared.com/rar/m6Utfwln/TC_online.html

Como este editor esta diseñado solo para consola, para DOS y UNIX, vamos a encontrar algunas cosas que
los compiladores modernos no incluyen, aunque DevC++ tiene paquetes instalables que permiten emular la libreria conio.h con conio2.h y la libreria graphics.h para obtener sobre consola algunas ventajas ya no disponibles en los modernos compiladores, que se han orientado a la presentacion grafica del sistema windows. (nigocios son nigocios)





Algunos ejemplos utilizando conio2.h o la original conio.h de TurboC++ de Borland
-------------------------------------------------------------------------------------------------------------------------
https://ar.answers.yahoo.com/question/index?qid=20160315205901AADOEjI

¿Como generar archivo.xml en c?

He estado buscando informacion sobre como generar archivos .xml en lenguaje c pero no eh encontrado mucho me podran ayudar con este problema

SEGUIR-->