WikiCabal - Contribuciones del usuario [es]

Curso de Programación en C/Prog131

2014-06-10T19:45:31Z

Perseuz: /* Prog131 */

__NOTOC__
* [[:#Prog131 | Más DEFINE]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog131 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

#include <stdio.h>

#define DOS 2 /* Puedes usar comentarios si quieres */
#define OW "La consistencia es el último refugio de l\
os con poco imaginación. - Oscar Wilde"
#define CUADRADO DOS*DOS
#define PX printf("X es %d.\n", x)
#define FMT "X es %d.\n"

int main(void)
{
int x = DOS;

PX;
x = CUADRADO;
printf(FMT, x);
printf("%s\n", OW);
printf("DOS: OW\n");
return 0;
}

</syntaxhighlight>

=== Resultado ===
<pre>
[rrc@pwyr CClase]$ gcc -Wall -O2 -o Prog131 Prog131.c
[rrc@pwyr CClase]$ ./Prog131
X es 2.
X es 4.
La consistencia es el último refugio de los con poco imaginación. - Oscar Wilde
DOS: OW
[rrc@pwyr CClase]$
</pre>

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog129

2014-06-10T16:36:34Z

Perseuz: /* Prog129 */

__NOTOC__
* [[:#Prog129 | Bitwise AND para pagar bits]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog129 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main( void )
{
unsigned char Mascara,
Semaforos;

char Buf[7];

int i,
Prueba;

puts( "\nEl bitwise AND es usado a veces para" );
puts( "apagar algunos bits en un entero\n" );
printf( "Dame un número positivo entre 0 y 255: " );
while( fgets( Buf, 5, stdin ) && Buf[0] != '\n' )
{
if( *(Buf + strlen( Buf ) -1 ) != '\n' )
{
fputs( "La línea que entraste es demasiado larga.\nSolo 3 chars MAX",
stderr );
exit(1);
}
*(Buf + strlen( Buf ) -1 ) = '\0';

for( i = 0; i < strlen( Buf ); i++ )
{
if( Buf[i] < '0' || Buf[i] > '9' )
{
fputs( "Caracteres ilegales en su ingreso\n", stderr );
exit(1);
}
}

Prueba = atoi( Buf);
if( Prueba > 255 )
{
fputs( "Su entrada está fuera del rango especificado\n", stderr );
exit(1);
}

for( i = 1; i <= 8; i++ )
{
switch( i )
{
case 1: Mascara = 0xfe;
Semaforos = Prueba;
Semaforos &= Mascara;
printf( "Su número %d se cambia a %d cuando bit %d está apagado\n",
Prueba, Semaforos, i -1 );
break;
case 2: Mascara = 0xfd;
Semaforos = Prueba;
Semaforos &= Mascara;
printf( "Su número %d se cambia a %d cuando bit %d está apagado\n",
Prueba, Semaforos, i -1 );
break;
case 3: Mascara = 0xfb;
Semaforos = Prueba;
Semaforos &= Mascara;
printf( "Su número %d se cambia a %d cuando bit %d está apagado\n",
Prueba, Semaforos, i -1 );
break;
case 4: Mascara = 0xf7;
Semaforos = Prueba;
Semaforos &= Mascara;
printf( "Su número %d se cambia a %d cuando bit %d está apagado\n",
Prueba, Semaforos, i -1 );
break;
case 5: Mascara = 0xef;
Semaforos = Prueba;
Semaforos &= Mascara;
printf( "Su número %d se cambia a %d cuando bit %d está apagado\n",
Prueba, Semaforos, i -1 );
break;
case 6: Mascara = 0xdf;
Semaforos = Prueba;
Semaforos &= Mascara;
printf( "Su número %d se cambia a %d cuando bit %d está apagado\n",
Prueba, Semaforos, i -1 );
break;
case 7: Mascara = 0xbf;
Semaforos = Prueba;
Semaforos &= Mascara;
printf( "Su número %d se cambia a %d cuando bit %d está apagado\n",
Prueba, Semaforos, i -1 );
break;
case 8: Mascara = 0x7f;
Semaforos = Prueba;
Semaforos &= Mascara;
printf( "Su número %d se cambia a %d cuando bit %d está apagado\n",
Prueba, Semaforos, i -1 );
break;
}
}
printf( "\nDame un número positivo entre 0 y 255"
" (<Enter> para terminar): " );
}
return 0;
}

</syntaxhighlight>

=== Resultado ===
<pre>
[rrc@AbelLap CClase]$ gcc -Wall -o Prog129 Prog129.c
[rrc@AbelLap CClase]$ ./Prog129

El bitwise AND es usado a veces para
apagar algunos bits en un entero

Dame un número positivo entre 0 y 255: 255
Su número 255 se cambia a 254 cuando bit 0 está apagado
Su número 255 se cambia a 253 cuando bit 1 está apagado
Su número 255 se cambia a 251 cuando bit 2 está apagado
Su número 255 se cambia a 247 cuando bit 3 está apagado
Su número 255 se cambia a 239 cuando bit 4 está apagado
Su número 255 se cambia a 223 cuando bit 5 está apagado
Su número 255 se cambia a 191 cuando bit 6 está apagado
Su número 255 se cambia a 127 cuando bit 7 está apagado

Dame un número positivo entre 0 y 255 (<Enter> para terminar): 127
Su número 127 se cambia a 126 cuando bit 0 está apagado
Su número 127 se cambia a 125 cuando bit 1 está apagado
Su número 127 se cambia a 123 cuando bit 2 está apagado
Su número 127 se cambia a 119 cuando bit 3 está apagado
Su número 127 se cambia a 111 cuando bit 4 está apagado
Su número 127 se cambia a 95 cuando bit 5 está apagado
Su número 127 se cambia a 63 cuando bit 6 está apagado
Su número 127 se cambia a 127 cuando bit 7 está apagado

Dame un número positivo entre 0 y 255 (<Enter> para terminar): 63
Su número 63 se cambia a 62 cuando bit 0 está apagado
Su número 63 se cambia a 61 cuando bit 1 está apagado
Su número 63 se cambia a 59 cuando bit 2 está apagado
Su número 63 se cambia a 55 cuando bit 3 está apagado
Su número 63 se cambia a 47 cuando bit 4 está apagado
Su número 63 se cambia a 31 cuando bit 5 está apagado
Su número 63 se cambia a 63 cuando bit 6 está apagado
Su número 63 se cambia a 63 cuando bit 7 está apagado

Dame un número positivo entre 0 y 255 (<Enter> para terminar): 31
Su número 31 se cambia a 30 cuando bit 0 está apagado
Su número 31 se cambia a 29 cuando bit 1 está apagado
Su número 31 se cambia a 27 cuando bit 2 está apagado
Su número 31 se cambia a 23 cuando bit 3 está apagado
Su número 31 se cambia a 15 cuando bit 4 está apagado
Su número 31 se cambia a 31 cuando bit 5 está apagado
Su número 31 se cambia a 31 cuando bit 6 está apagado
Su número 31 se cambia a 31 cuando bit 7 está apagado

Dame un número positivo entre 0 y 255 (<Enter> para terminar): 15
Su número 15 se cambia a 14 cuando bit 0 está apagado
Su número 15 se cambia a 13 cuando bit 1 está apagado
Su número 15 se cambia a 11 cuando bit 2 está apagado
Su número 15 se cambia a 7 cuando bit 3 está apagado
Su número 15 se cambia a 15 cuando bit 4 está apagado
Su número 15 se cambia a 15 cuando bit 5 está apagado
Su número 15 se cambia a 15 cuando bit 6 está apagado
Su número 15 se cambia a 15 cuando bit 7 está apagado

Dame un número positivo entre 0 y 255 (<Enter> para terminar): 7
Su número 7 se cambia a 6 cuando bit 0 está apagado
Su número 7 se cambia a 5 cuando bit 1 está apagado
Su número 7 se cambia a 3 cuando bit 2 está apagado
Su número 7 se cambia a 7 cuando bit 3 está apagado
Su número 7 se cambia a 7 cuando bit 4 está apagado
Su número 7 se cambia a 7 cuando bit 5 está apagado
Su número 7 se cambia a 7 cuando bit 6 está apagado
Su número 7 se cambia a 7 cuando bit 7 está apagado

Dame un número positivo entre 0 y 255 (<Enter> para terminar): 3
Su número 3 se cambia a 2 cuando bit 0 está apagado
Su número 3 se cambia a 1 cuando bit 1 está apagado
Su número 3 se cambia a 3 cuando bit 2 está apagado
Su número 3 se cambia a 3 cuando bit 3 está apagado
Su número 3 se cambia a 3 cuando bit 4 está apagado
Su número 3 se cambia a 3 cuando bit 5 está apagado
Su número 3 se cambia a 3 cuando bit 6 está apagado
Su número 3 se cambia a 3 cuando bit 7 está apagado

Dame un número positivo entre 0 y 255 (<Enter> para terminar): 1
Su número 1 se cambia a 0 cuando bit 0 está apagado
Su número 1 se cambia a 1 cuando bit 1 está apagado
Su número 1 se cambia a 1 cuando bit 2 está apagado
Su número 1 se cambia a 1 cuando bit 3 está apagado
Su número 1 se cambia a 1 cuando bit 4 está apagado
Su número 1 se cambia a 1 cuando bit 5 está apagado
Su número 1 se cambia a 1 cuando bit 6 está apagado
Su número 1 se cambia a 1 cuando bit 7 está apagado

Dame un número positivo entre 0 y 255 (<Enter> para terminar): 0
Su número 0 se cambia a 0 cuando bit 0 está apagado
Su número 0 se cambia a 0 cuando bit 1 está apagado
Su número 0 se cambia a 0 cuando bit 2 está apagado
Su número 0 se cambia a 0 cuando bit 3 está apagado
Su número 0 se cambia a 0 cuando bit 4 está apagado
Su número 0 se cambia a 0 cuando bit 5 está apagado
Su número 0 se cambia a 0 cuando bit 6 está apagado
Su número 0 se cambia a 0 cuando bit 7 está apagado

Dame un número positivo entre 0 y 255 (<Enter> para terminar): 35
Su número 35 se cambia a 34 cuando bit 0 está apagado
Su número 35 se cambia a 33 cuando bit 1 está apagado
Su número 35 se cambia a 35 cuando bit 2 está apagado
Su número 35 se cambia a 35 cuando bit 3 está apagado
Su número 35 se cambia a 35 cuando bit 4 está apagado
Su número 35 se cambia a 3 cuando bit 5 está apagado
Su número 35 se cambia a 35 cuando bit 6 está apagado
Su número 35 se cambia a 35 cuando bit 7 está apagado

Dame un número positivo entre 0 y 255 (<Enter> para terminar):
[rrc@AbelLap CClase]$
</pre>

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog125

2014-06-07T23:58:17Z

Perseuz: /* Prog125 */

__NOTOC__
* [[:#Prog125 | Pointers de funciones]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog125 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

char DesplegaMenu( void );
void ComeLinea( void );
void Desplega( void (* fp)( char * ), char * str );
void AMayuscula( char * );
void AMinuscula( char * );
void Invierta( char * );
void Tonto( char * );

int main(void)
{
char Linea[81];
char Copia[81];
char Seleccion;
void (*pfun)(char *); // Declarar un pointer a función, pfun, que tiene
// argumento de char * y no valor de returno
printf( "\nIngresa una línea (<Enter> para terminar): " );
while( fgets( Linea, 79, stdin ) && Linea[0] != '\n' )
{
if( *(Linea + strlen( Linea ) -1 ) != '\n' )
{
fputs( "La línea que entraste es demasiado largo.\nSolo 79 chars MAX",
stderr );
exit(1);
}
*(Linea + strlen( Linea ) -1 ) = '\0';

while( ( Seleccion = DesplegaMenu() ) != 's' )
{
switch( Seleccion )
{
case 'y' : pfun = AMayuscula; break;
case 'n' : pfun = AMinuscula; break;
case 'i' : pfun = Invierta; break;
case 'o' : pfun = Tonto; break;
}
strcpy( Copia, Linea );
Desplega( pfun, Copia );
}
printf( "\nIngresa una línea (<Enter> para terminar): " );
}
puts( "\n¡Adios!\n" );
return 0;
}

char DesplegaMenu( void )
{
char ans;
puts( "\n\t\ty) Todo Mayúsculas \t\tn) Todo Minúsculas" );
puts( "\t\ti) Invertir \t\to) Cómo original" );
puts( "\t\ts) Siguiente string" );
printf( "\tElige una opción: " );
ans = getchar();
ans = tolower(ans);
ComeLinea();
while( strchr( "ynios", ans ) == NULL )
{
printf( "\tElige y, n, i, o, o s: " );
ans = tolower( getchar() );
ComeLinea();
}
return ans;
}

void ComeLinea( void )
{
while( getchar() != '\n' )
continue;
}

void AMayuscula( char * str )
{
while( *str )
{
*str = toupper( *str );
str++;
}
}

void AMinuscula( char * str )
{
while( *str )
{
*str = tolower( *str );
str++;
}
}

void Invierta( char * str )
{
while( *str )
{
if( islower( *str ) )
*str = toupper( *str );
else if( isupper( *str ) )
*str = tolower( *str );
str++;
}
}

void Tonto(char * str)
{
// No cambio el string
}

void Desplega( void (* fp)( char * ), char * str )
{
(*fp)( str ); // aplicar la función
printf( "\n\tEl Resultado: %s\n", str );
}

</syntaxhighlight>

=== Resultado ===
<pre>
[rrc@localhost CClase]$ gcc -Wall -o Prog125 Prog125.c
[rrc@localhost CClase]$ ./Prog125

Ingresa una línea (<Enter> para terminar):

¡Adios!

[rrc@localhost CClase]$ ./Prog125

Ingresa una línea (<Enter> para terminar): Una Línea

y) Todo Mayúsculas n) Todo Minúsculas
i) Invertir o) Cómo original
s) Siguiente string
Elige un opción: y

El Resultado: UNA LíNEA

y) Todo Mayúsculas n) Todo Minúsculas
i) Invertir o) Cómo original
s) Siguiente string
Elige un opción: n

El Resultado: una línea

y) Todo Mayúsculas n) Todo Minúsculas
i) Invertir o) Cómo original
s) Siguiente string
Elige un opción: o

El Resultado: Una Línea

y) Todo Mayúsculas n) Todo Minúsculas
i) Invertir o) Cómo original
s) Siguiente string
Elige un opción: i

El Resultado: uNA líNEA

y) Todo Mayúsculas n) Todo Minúsculas
i) Invertir o) Cómo original
s) Siguiente string
Elige un opción: s

Ingresa una línea (<Enter> para terminar): OTRA línea

y) Todo Mayúsculas n) Todo Minúsculas
i) Invertir o) Cómo original
s) Siguiente string
Elige un opción: y

El Resultado: OTRA LíNEA

y) Todo Mayúsculas n) Todo Minúsculas
i) Invertir o) Cómo original
s) Siguiente string
Elige un opción: r
Elige y, n, i, o, o s: i

El Resultado: otra LíNEA

y) Todo Mayúsculas n) Todo Minúsculas
i) Invertir o) Cómo original
s) Siguiente string
Elige un opción: n

El Resultado: otra línea

y) Todo Mayúsculas n) Todo Minúsculas
i) Invertir o) Cómo original
s) Siguiente string
Elige un opción: o

El Resultado: OTRA línea

y) Todo Mayúsculas n) Todo Minúsculas
i) Invertir o) Cómo original
s) Siguiente string
Elige un opción: s

Ingresa una línea (<Enter> para terminar):

¡Adios!

[rrc@localhost CClase]$
</pre>

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog124

2014-06-07T16:02:06Z

Perseuz: /* Prog124 */

__NOTOC__
* [[:#Prog124 | enum]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog124 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

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

enum espectro { rojo, naranja, amarillo, verde, azul, violeta };

const char * colores[] = {"rojo", "naranja", "amarillo",
"verde", "azul", "violeta"};
#define TAMANO 30

int main(void)
{
char opcion[TAMANO],
prueba[TAMANO];

enum espectro color;

int i;

bool color_se_encuentra = false;

printf( "Ingresa un color (<Enter> para terminar): " );
while( fgets( opcion, TAMANO - 2, stdin ) && opcion[0] != '\n' )
{
if( *(opcion + strlen( opcion ) -1 ) != '\n' )
{
printf( "El color que entraste es demasiado largo.\n"
"Solo %d chars MAX\n", TAMANO - 2 );
exit(1);
}
else
*(opcion + strlen( opcion ) -1 ) = '\0';

for( i = 0; i < strlen( opcion ); i++ )
prueba[i] = tolower( opcion[i] );
prueba[i] = '\0';

for( color = rojo; color <= violeta; color++ )
{
if( strcmp( prueba, colores[color] ) == 0 )
{
color_se_encuentra = true;
break;
}
}

if( color_se_encuentra )
switch( color )
{
case rojo :
puts( "Las Rosas son de color rojo." );
break;
case naranja :
puts( "Las amapolas son de color naranja." );
break;
case amarillo :
puts( "Las girasoles son de color amarillo." );
break;
case verde :
puts( "La hierba es de color verde." );
break;
case azul :
puts( "Las jacintos son de color azul." );
break;
case violeta :
puts( "Las violetas son de color violeta." );
break;
}
else
printf( "No conozco el color %s.\n", opcion );
color_se_encuentra = false;
printf( "Ingresa un color (<Enter> para terminar): " );
}
puts( "\n¡Adios!\n" );
return 0;
}

</syntaxhighlight>

=== Resultado ===
<pre>
[rrc@localhost CClase]$ gcc -Wall -o Prog123 Prog123.c
[rrc@localhost CClase]$ ./Prog123
Ingresa un color (<Enter> para terminar): verde
La hierba es de color verde.
Ingresa un color (<Enter> para terminar): VIOLETA
Las violetas son de color violeta.
Ingresa un color (<Enter> para terminar): AzUl
Las jacintos son de color azul.
Ingresa un color (<Enter> para terminar): AmarillO
Las girasoles son de color amarillo.
Ingresa un color (<Enter> para terminar): Purple
No conozco el color Purple.
Ingresa un color (<Enter> para terminar):

¡Adios!

[rrc@localhost CClase]$
</pre>

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog122

2014-06-06T19:11:57Z

Perseuz: /* Prog122 */

__NOTOC__
* [[:#Prog122 | Guardar un iarreglo de structs en un archivo]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog122 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

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

#define MAXTITL 40
#define MAXAUTL 40
#define MAXVALL 12
#define MAXLIBROS 100

struct Libro {
char Titulo[MAXTITL];
char Autor[MAXAUTL];
float Valor;
};

int main( void )
{
struct Libro Biblioteca[MAXLIBROS];

int Conteo = 0,
ConteoDelArchivo,
Index,
NumPuntos,
Tamano = sizeof( struct Libro ),
i;

char ValSTR[MAXVALL];

FILE * PLibros;

if( ( PLibros = fopen( "Libros.dat", "a+b" ) ) == NULL )
{
fputs( "No puedo abrir Libros.dat\n", stderr );
exit( 1 );
}

rewind( PLibros );

while( Conteo < MAXLIBROS &&
fread( &Biblioteca[Conteo], Tamano, 1, PLibros ) == 1 )
{
if( Conteo == 0 )
puts( "Los contenidos de Libros.dat ahora:" );
printf( "\t%s por %s: $%.2f\n", Biblioteca[Conteo].Titulo,
Biblioteca[Conteo].Autor,
Biblioteca[Conteo].Valor );
Conteo++;
}

ConteoDelArchivo = Conteo;

if( Conteo == MAXLIBROS )
{
fputs( "El archivo: Libros.dat está lleno.", stderr );
fclose( PLibros );
exit( 2 );
}

printf( "\nIngresa el nombre del libro: " );
while( Conteo < MAXLIBROS )
{
if( fgets( Biblioteca[Conteo].Titulo, MAXTITL - 2, stdin ) &&
Biblioteca[Conteo].Titulo[0] != '\n' )
{
if( *(Biblioteca[Conteo].Titulo +
strlen( Biblioteca[Conteo].Titulo ) -1 ) != '\n' )
{
fprintf( stderr, "El titulo que entraste es demasiado largo.\n"
"Solo %d chars MAX\n", MAXTITL - 2 );
fclose( PLibros );
exit(1);
}

*(Biblioteca[Conteo].Titulo +
strlen( Biblioteca[Conteo].Titulo ) -1 ) = '\0';
}
else
break;

printf( "Ingresa el nombre del autor: " );
if( fgets( Biblioteca[Conteo].Autor, MAXAUTL - 2, stdin ) &&
Biblioteca[Conteo].Autor[0] != '\n' )
{
if( *(Biblioteca[Conteo].Autor +
strlen( Biblioteca[Conteo].Autor ) -1 ) != '\n' )
{
fprintf( stderr, "El autor que entraste es demasiado largo.\n"
"Solo %d chars MAX\n", MAXAUTL - 2 );
fclose( PLibros );
exit(1);
}

*(Biblioteca[Conteo].Autor +
strlen( Biblioteca[Conteo].Autor ) -1 ) = '\0';
}
else
{
fprintf( stderr, "Falta el nombre del autor de \"%s\"\n",
Biblioteca[Conteo].Titulo );
fclose( PLibros );
exit(1);
}

NumPuntos = 0;
printf( "Ingresa el valor: " );
if( fgets( ValSTR, MAXVALL - 2, stdin ) && ValSTR[0] != '\n' )
{
if( *(ValSTR + strlen( ValSTR ) -1 ) != '\n' )
{
fprintf( stderr, "El valor que entraste es demasiado largo.\n"
"Solo %d chars MAX\n", MAXVALL - 2 );
fclose( PLibros );
exit(1);
}

*(ValSTR + strlen( ValSTR ) -1 ) = '\0';

if( ValSTR[0] == '-' )
{
fputs( "No se permiten valores negativos.", stderr );
fclose( PLibros );
exit(1);
}

for( i = 0; i < strlen( ValSTR ) - 1; i++ )
{
if( ValSTR[i] < '0' || ValSTR[i] > '9' )
{
if( ValSTR[i] == '.' )
{
if( ++NumPuntos > 1 )
{
fprintf( stderr, "Se permite solo 1 punto.\n" );
fclose( PLibros );
exit(1);
}

if( strlen( ValSTR ) - i > 3 )
{
fputs( "Se permiten solo 2 decimales después del punto.", stderr );
fclose( PLibros );
exit(1);
}
}
else
{
fputs( "Caracteres ilegales en su valor.", stderr );
fclose( PLibros );
exit(1);
}
}
}

Biblioteca[Conteo++].Valor = atof( ValSTR );
}
else
{
fprintf( stderr, "Falta el valor de \"%s\"\n", Biblioteca[Conteo].Titulo );
fclose( PLibros );
exit(1);
}

if( Conteo < MAXLIBROS )
printf( "Ingresa el sigiuente titulo: (<Enter> para terminar): " );
}

if (Conteo > 0)
{
puts( "\nAquí es la lista de sus libros:" );
for( Index = 0; Index < Conteo; Index++ )
printf( "\t\"%s\" por \"%s\": $%.2f\n", Biblioteca[Index].Titulo,
Biblioteca[Index].Autor,
Biblioteca[Index].Valor );
fwrite( &Biblioteca[ConteoDelArchivo], Tamano, Conteo - ConteoDelArchivo,
PLibros );
}
else
puts( "Lo siento pero no tengo libros nuevos para mostrar." );

puts( "\n¡Adios!\n" );
fclose( PLibros );
return 0;
}
</syntaxhighlight>

=== Resultado ===
<pre>
[rrc@llawyr CClase]$ rm Libros.dat
rm: remove regular file `Libros.dat'? y
[rrc@llawyr CClase]$ gcc -Wall -o Prog122 Prog122.c
[rrc@llawyr CClase]$ ./Prog122

Ingresa el nombre del libro:
Lo siento pero no tengo libros nuevos para mostrar.

¡Adios!

[rrc@llawyr CClase]$ ./Prog122

Ingresa el nombre del libro: Libro Uno
Ingresa el nombre del autor: Autor uno
Ingresa el valor: Valor 1
Caracteres ilegales en su valor.
[rrc@llawyr CClase]$ ./Prog122

Ingresa el nombre del libro: Libro Uno
Ingresa el nombre del autor: Autor Uno
Ingresa el valor: 13.55
Ingresa el siguiente titulo: (<Enter> para terminar): Libro Dos
Ingresa el nombre del autor: Autor 2
Ingresa el valor: 52.66
Ingresa el siguiente titulo: (<Enter> para terminar):

Aquí esta la lista de sus libros:
"Libro Uno" por "Autor Uno": $13.55
"Libro Dos" por "Autor 2": $52.66

¡Adios!

[rrc@llawyr CClase]$ ./Prog122
Los contenidos de Libros.dat ahora:
Libro Uno por Autor Uno: $13.55
Libro Dos por Autor 2: $52.66

Ingresa el nombre del libro: Libro Tres
Ingresa el nombre del autor: Autor Tres
Ingresa el valor: 62.88
Ingresa el siguiente titulo: (<Enter> para terminar): Libro Cuatro
Ingresa el nombre del autor: Autor Cuatro
Ingresa el valor: 62.44
Ingresa el siguiente titulo: (<Enter> para terminar):

Aquí esta la lista de sus libros:
"Libro Uno" por "Autor Uno": $13.55
"Libro Dos" por "Autor 2": $52.66
"Libro Tres" por "Autor Tres": $62.88
"Libro Cuatro" por "Autor Cuatro": $62.44

¡Adios!

[rrc@llawyr CClase]$ ./Prog122
Los contenidos de Libros.dat ahora:
Libro Uno por Autor Uno: $13.55
Libro Dos por Autor 2: $52.66
Libro Tres por Autor Tres: $62.88
Libro Cuatro por Autor Cuatro: $62.44

Ingresa el nombre del libro:

Aquí esta la lista de sus libros:
"Libro Uno" por "Autor Uno": $13.55
"Libro Dos" por "Autor 2": $52.66
"Libro Tres" por "Autor Tres": $62.88
"Libro Cuatro" por "Autor Cuatro": $62.44

¡Adios!

[rrc@llawyr CClase]$
</pre>

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog121

2014-06-06T18:09:14Z

Perseuz: /* Prog121 */

__NOTOC__
* [[:#Prog121 | Funciones que regresan structs]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog121 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

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

#define MAXNOMBRELEN 20

struct NombreConteo
{
char Nombre[MAXNOMBRELEN];
char Apellido[MAXNOMBRELEN];
int Letras;
};

struct NombreConteo ObtenInfo( void );
struct NombreConteo mkInfo( struct NombreConteo );
void DesplegaInfo( const struct NombreConteo );

int main( void )
{
struct NombreConteo Persona;

Persona = ObtenInfo();
Persona = mkInfo( Persona );
DesplegaInfo( Persona );
return 0;
}

struct NombreConteo ObtenInfo( void )
{
struct NombreConteo temp;

printf( "Favor de ingresar su nombre: " );
if( fgets( temp.Nombre, MAXNOMBRELEN - 2, stdin ) &&
temp.Nombre[0] != '\n' )
{
if( *(temp.Nombre + strlen( temp.Nombre ) -1 ) != '\n' )
{
printf( "El Nombre que entraste es demasiado largo.\n"
"Solo %d chars MAX\n", MAXNOMBRELEN - 2 );
exit(1);
}

*(temp.Nombre + strlen( temp.Nombre ) -1 ) = '\0';
}
else
{
puts( "Falta su Nombre" );
exit(1);
}

printf( "Favor de ingresar su apellido paterno: " );
if( fgets( temp.Apellido, MAXNOMBRELEN - 2, stdin ) &&
temp.Apellido[0] != '\n' )
{
if( *(temp.Apellido + strlen( temp.Apellido ) -1 ) != '\n' )
{
printf( "El apellido paterno que entraste es demasiado largo.\n"
"Solo %d chars MAX\n", MAXNOMBRELEN - 2 );
exit(1);
}

*(temp.Apellido + strlen( temp.Apellido ) -1 ) = '\0';
}
else
{
puts( "Falta su apellido paterno" );
exit(1);
}
return temp;
}

struct NombreConteo mkInfo( struct NombreConteo info )
{
info.Letras = strlen( info.Nombre ) +
strlen( info.Apellido );
return info;
}

void DesplegaInfo( const struct NombreConteo info )
{
printf( "%s %s, tu nombre contiene %d Letras.\n",
info.Nombre, info.Apellido, info.Letras );
}

</syntaxhighlight>

=== Resultado ===
<pre>
[rrc@llawyr CClase]$ gcc -Wall -o Prog121 Prog121.c
[rrc@llawyr CClase]$ ./Prog121
Favor de ingresar su nombre:
Falta su Nombre
[rrc@llawyr CClase]$ ./Prog121
Favor de ingresar su nombre: RichardConMuchasLetras
El Nombre que entraste es demasiado largo.
Solo 18 chars MAX
[rrc@llawyr CClase]$ ./Prog121
Favor de ingresar su nombre: Richard
Favor de ingresar su apellido paterno: Couture
Richard Couture, tu nombre contiene 14 Letras.
[rrc@llawyr CClase]$
</pre>

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog120

2014-06-06T16:51:12Z

Perseuz: /* Prog120 */

__NOTOC__
* [[:#Prog120 | Pasando structs en funciones]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog120 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

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

#define MAXNOMBRELEN 20

struct NombreConteo
{
char Nombre[MAXNOMBRELEN];
char Apellido[MAXNOMBRELEN];
int Letras;
};

void ObtenInfo( struct NombreConteo * );
void mkInfo( struct NombreConteo * );
void DesplegaInfo( const struct NombreConteo * );

int main( void )
{
struct NombreConteo Persona;

ObtenInfo( &Persona );
mkInfo( &Persona );
DesplegaInfo( &Persona );
return 0;
}

void ObtenInfo( struct NombreConteo * pst )
{
printf( "Favor de ingresar su nombre: " );
if( fgets( pst->Nombre, MAXNOMBRELEN - 2, stdin ) &&
pst->Nombre[0] != '\n' )
{
if( *(pst->Nombre + strlen( pst->Nombre ) -1 ) != '\n' )
{
printf( "El Nombre que entraste es demasiado largo.\n"
"Solo %d chars MAX\n", MAXNOMBRELEN - 2 );
exit(1);
}

*(pst->Nombre + strlen( pst->Nombre ) -1 ) = '\0';
}
else
{
puts( "Falta su Nombre" );
exit(1);
}

printf( "Favor de ingresar su apellido paterno: " );
if( fgets( pst->Apellido, MAXNOMBRELEN - 2, stdin ) &&
pst->Apellido[0] != '\n' )
{
if( *(pst->Apellido + strlen( pst->Apellido ) -1 ) != '\n' )
{
printf( "El apellido paterno que entraste es demasiado largo.\n"
"Solo %d chars MAX\n", MAXNOMBRELEN - 2 );
exit(1);
}

*(pst->Apellido + strlen( pst-> Apellido ) -1 ) = '\0';
}
else
{
puts( "Falta su apellido paterno" );
exit(1);
}
}

void mkInfo( struct NombreConteo * pst )
{
pst->Letras = strlen( pst->Nombre ) +
strlen( pst->Apellido );
}

void DesplegaInfo( const struct NombreConteo * pst )
{
printf( "%s %s, tu nombre contiene %d Letras.\n",
pst->Nombre, pst->Apellido, pst->Letras );
}

</syntaxhighlight>

=== Resultado ===
<pre>
[rrc@llawyr CClase]$ gcc -Wall -o Prog120 Prog120.c
[rrc@llawyr CClase]$ ./Prog120
Favor de ingresar su nombre:
Falta su Nombre
[rrc@llawyr CClase]$ ./Prog120
Favor de ingresar su nombre: RichardConMuchasLetras
El Nombre que entraste es demasiado largo.
Solo 18 chars MAX
[rrc@llawyr CClase]$ ./Prog120
Favor de ingresar su nombre: Richard
Favor de ingresar su apellido paterno: Couture
Richard Couture, tu nombre contiene 14 Letras.
[rrc@llawyr CClase]$
</pre>

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog119

2014-06-05T22:33:37Z

Perseuz: /* Prog119 */

__NOTOC__
* [[:#Prog119 | Pointers de struct]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog119 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

#include <stdio.h>

#define LARGO 20

struct Nombres {
char Nombre[LARGO];
char Apellido[LARGO];
};

struct Personas {
struct Nombres handle;
char ComidaPreferida[LARGO];
char Profesion[LARGO];
float IngresosMensual;
};

int main( void )
{
struct Personas Companero[2] =
{
{
{ "Horacio", "Villanueva" },
"salmon",
"Gigolo",
58112.00
},

{
{"Rupert", "Delgado" },
"menudo",
"Editor de Revistas",
32400.00
}
};

struct Personas * El; /* here is a pointer to a structure */
El = &Companero[0]; /* tell the pointer where to point */

printf( "\npointer: %p\n", El );
printf( "Nombre: %s\n", El->handle.Nombre );
printf( "Apellido: %s\n", El->handle.Apellido );
printf( "Comida Preferida: %s\n", El->ComidaPreferida );
printf( "Profesión: %s\n", El->Profesion );
printf( "Ingreso Mensual: %.2f\n", El->IngresosMensual );

El++; /* point to the next structure */

printf( "\npointer: %p\n", El );
printf( "Nombre: %s\n", (*El).handle.Nombre );
printf( "Apellido: %s\n", (*El).handle.Apellido );
printf( "Comida Preferida: %s\n", (*El).ComidaPreferida );
printf( "Profesión: %s\n", (*El).Profesion );
printf( "Ingreso Mensual: %.2f\n\n", (*El).IngresosMensual );

return 0;
}
</syntaxhighlight>

=== Resultado ===
<pre>
pointer: 0x7ffffaec23a0
Nombre: Horacio
Apellido: Villanueva
Comida Preferida: salmon
Profesión: Gigolo
Ingreso Mensual: 58112.00

pointer: 0x7ffffaec23f4
Nombre: Rupert
Apellido: Delgado
Comida Preferida: menudo
Profesión: Editor de Revistas
Ingreso Mensual: 32400.00

[rrc@llawyr CClase]$
</pre>

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog118

2014-06-04T22:32:50Z

Perseuz: /* Prog118 */

__NOTOC__
* [[:#Prog118 | Arreglos de structs]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog118 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

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

#define MAXTITL 40
#define MAXAUTL 40
#define MAXVALL 12
#define MAXLIBROS 100

struct Libro {
char Titulo[MAXTITL];
char Autor[MAXAUTL];
float Valor;
};

int main( void )
{
struct Libro Biblioteca[MAXLIBROS];
int Conteo = 0,
Index,
NumPuntos,
i;
char ValSTR[MAXVALL];

printf( "Ingresa el nombre del libro: " );
while( Conteo < MAXLIBROS )
{
if( fgets( Biblioteca[Conteo].Titulo, MAXTITL - 2, stdin ) &&
Biblioteca[Conteo].Titulo[0] != '\n' )
{
if( *(Biblioteca[Conteo].Titulo +
strlen( Biblioteca[Conteo].Titulo ) -1 ) != '\n' )
{
printf( "El titulo que entraste es demasiado largo.\n"
"Solo %d chars MAX\n", MAXTITL - 2 );
exit(1);
}

*(Biblioteca[Conteo].Titulo +
strlen( Biblioteca[Conteo].Titulo ) -1 ) = '\0';
}
else
break;

printf( "Ingresa el nombre del autor: " );
if( fgets( Biblioteca[Conteo].Autor, MAXAUTL - 2, stdin ) &&
Biblioteca[Conteo].Autor[0] != '\n' )
{
if( *(Biblioteca[Conteo].Autor +
strlen( Biblioteca[Conteo].Autor ) -1 ) != '\n' )
{
printf( "El autor que entraste es demasiado largo.\n"
"Solo %d chars MAX\n", MAXAUTL - 2 );
exit(1);
}

*(Biblioteca[Conteo].Autor +
strlen( Biblioteca[Conteo].Autor ) -1 ) = '\0';
}
else
{
printf( "Faltan el nombre del autor de \"%s\"\n",
Biblioteca[Conteo].Titulo );
exit(1);
}

NumPuntos = 0;
printf( "Ingresa el valor: " );
if( fgets( ValSTR, MAXVALL - 2, stdin ) && ValSTR[0] != '\n' )
{
if( *(ValSTR + strlen( ValSTR ) -1 ) != '\n' )
{
printf( "El valor que entraste es demasiado largo.\n"
"Solo %d chars MAX\n", MAXVALL - 2 );
exit(1);
}

*(ValSTR + strlen( ValSTR ) -1 ) = '\0';

if( ValSTR[0] == '-' )
{
puts( "No se permiten valores negativos." );
exit(1);
}

for( i = 0; i < strlen( ValSTR ) - 1; i++ )
{
if( ValSTR[i] < '0' || ValSTR[i] > '9' )
{
if( ValSTR[i] == '.' )
{
if( ++NumPuntos > 1 )
{
fprintf( stderr, "Se permite solo 1 punto.\n" );
exit(1);
}

if( strlen( ValSTR ) - i > 3 )
{
puts( "Se permiten solo 2 decimales después del punto." );
exit(1);
}
}
else
{
puts( "Caracteres ilegales en su valor." );
exit(1);
}
}
}

Biblioteca[Conteo++].Valor = atof( ValSTR );
}
else
{
printf( "Faltan el valor de \"%s\"\n", Biblioteca[Conteo].Titulo );
exit(1);
}

if( Conteo < MAXLIBROS )
printf( "Ingresa el siguiente titulo: (<Enter> para terminar): " );
}

if (Conteo > 0)
{
puts( "Aquí está la lista de tus libros:" );
for (Index = 0; Index < Conteo; Index++)
printf( "\t\"%s\" por \"%s\": $%.2f\n", Biblioteca[Index].Titulo,
Biblioteca[Index].Autor, Biblioteca[Index].Valor);
}
else
puts( "Lo siento pero no tengo libros para mostrar." );

return 0;
}
</syntaxhighlight>

=== Resultado ===
<pre>
[rrc@llawyr CClase]$ gcc -Wall -o Prog118 Prog118.c
[rrc@llawyr CClase]$ ./Prog118
Ingresa el nombre del libro:
Lo siento pero no tengo libros para mostrar.
[rrc@llawyr CClase]$ ./Prog118
Ingresa el nombre del libro: Libro 118
Ingresa el nombre del autor:
Faltan el nombre del autor de "Libro 118"
[rrc@llawyr CClase]$ gcc -Wall -o Prog118 Prog118.c
[rrc@llawyr CClase]$ ./Prog118
Ingresa el nombre del libro: Libro 1
Ingresa el nombre del autor: Autor 1
Ingresa el valor:
Faltan el valor de "Libro 1"
[rrc@llawyr CClase]$ ./Prog118
Ingresa el nombre del libro: Libro 1
Ingresa el nombre del autor: Autor 1
Ingresa el valor: 34
Ingresa el siguiente titulo: (<Enter> para terminar):
Aquí está la lista de tus libros:
"Libro 1" por "Autor 1": $34.00
[rrc@llawyr CClase]$ ./Prog118
Ingresa el nombre del libro: Libro 1
Ingresa el nombre del autor: Autor 1
Ingresa el valor: 45.33
Ingresa el siguiente titulo: (<Enter> para terminar): Libro 2
Ingresa el nombre del autor: Autor 2
Ingresa el valor: 53
Ingresa el siguiente titulo: (<Enter> para terminar):
Aquí es la lista de sus libros:
"Libro 1" por "Autor 1": $45.33
"Libro 2" por "Autor 2": $53.00
[rrc@llawyr CClase]$
</pre>

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog117

2014-06-04T15:13:29Z

Perseuz: /* Prog117 */

__NOTOC__
* [[:#Prog117 | struct]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog117 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAXTITL 41
#define MAXAUTL 31
#define MAXVALL 10

struct Libro
{
char Titulo[MAXTITL];
char Autor[MAXAUTL];
float Valor;
};

int main( void )
{
int i;
char ValSTR[MAXVALL + 1];
struct Libro Biblio;

printf( "Ingresa el nombre del libro: " );

fgets( Biblio.Titulo, MAXTITL - 2, stdin );

if( *(Biblio.Titulo + strlen( Biblio.Titulo ) -1 ) != '\n' )
{
printf( "El nombre que entraste es demasiado largo.\n"
"Solo %d chars MAX\n", MAXTITL - 2 );
exit(1);
}
else
*(Biblio.Titulo + strlen( Biblio.Titulo ) -1 ) = '\0';

printf( "Ingresa el nombre del autor: " );

fgets( Biblio.Autor, MAXAUTL - 2, stdin );

if( *(Biblio.Autor + strlen( Biblio.Autor ) -1 ) != '\n' )
{
printf( "El nombre que entraste es demasiado largo.\n"
"Solo %d chars MAX\n", MAXAUTL - 2 );
exit(1);
}
else
*(Biblio.Autor + strlen( Biblio.Autor ) -1 ) = '\0';

printf( "Ingresa el valor: " );
scanf( "%10s", ValSTR );

if( strlen( ValSTR ) > MAXVALL -1 )
{
printf( "El valor que entraste es demasiado largo.\n"
"Solo %d chars MAX\n", MAXVALL - 1 );
exit(1);
}

if( ValSTR[0] == '-' )
{
puts( "No se permiten valores negativos." );
exit(1);
}

for( i = 0; i < strlen( ValSTR ) - 1; i++ )
{
if( ValSTR[i] < '0' || ValSTR[i] > '9' )
{
if( ValSTR[i] == '.' )
{
if( strlen( ValSTR ) - i > 3 )
{
puts( "Se permiten solo 2 decimales después del punto." );
exit(1);
}
}
else
{
puts( "Caracteres ilegales en su valor." );
exit(1);
}
}
}

Biblio.Valor = atof( ValSTR );

printf( "%s por %s: $%.2f\n", Biblio.Titulo,
Biblio.Autor, Biblio.Valor );
printf( "%s: \"%s\" ($%.2f)\n", Biblio.Autor,
Biblio.Titulo, Biblio.Valor );
printf( "Listo.\n" );

return 0;
}
</syntaxhighlight>

=== Resultado ===
<pre>
[rrc@llawyr CClase]$ gcc -Wall -o Prog117 Prog117.c
[rrc@llawyr CClase]$ ./Prog117
Ingresa el nombre del libro: Mi Libro
Ingresa el nombre del autor: El Autor
Ingresa el valor: 345
Mi Libro por El Autor: $345.00
El Autor: "Mi Libro" ($345.00)
Listo.
[rrc@llawyr CClase]$ ./Prog117
Ingresa el nombre del libro: Mi Otro Libro
Ingresa el nombre del autor: El otro Autor
Ingresa el valor: -34.56
Se permiten valores negativos.
[rrc@llawyr CClase]$ ./Prog117
Ingresa el nombre del libro: Un Otro Libro
Ingresa el nombre del autor: Un Otro Auto
Ingresa el valor: 4567543.34
El valor que entraste es demasiado largo.
Solo 9 chars MAX
[rrc@llawyr CClase]$ ./Prog117
Ingresa el nombre del libro: Otro Libro
Ingresa el nombre del autor: Otro Autor
Ingresa el valor: 34566.456
Se permiten solo 2 numerales después del punto.
[rrc@llawyr CClase]$ ./Prog117
Ingresa el nombre del libro: Otro Libro
Ingresa el nombre del autor: Otra Autora
Ingresa el valor: 345r.56
Caracteres ilegales en su valor.
[rrc@llawyr CClase]$ ./Prog117
Ingresa el nombre del libro: Ultimo Libro
Ingresa el nombre del autor: Ultimo Autor
Ingresa el valor: 435456.43
Ultimo Libro por Ultimo Autor: $435456.44
Ultimo Autor: "Ultimo Libro" ($435456.44)
Listo.
[rrc@llawyr CClase]$
</pre>

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog115

2014-06-04T03:16:40Z

Perseuz: /* Prog115 */

__NOTOC__
* [[:#Prog115 | fopen con "a", setvbuf() y ferror() ]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog115 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

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

#define BUFTAMANO 1024
#define STROZO 81

void append( FILE *Fuente, FILE *dest );

int main( void )
{
FILE *ADest,
*AFuente;

int Archivos = 0;

char ArchivoDestino[STROZO], // Nombre de archivo de fuente
ArchivoFuente[STROZO]; // Nombre de archivo de destino

printf( "Ingresa el nombre del archivo de destino: " );
fgets( ArchivoDestino, STROZO - 2, stdin );

if( *(ArchivoDestino + strlen( ArchivoDestino ) -1 ) != '\n' )
{
printf( "El nombre que entraste es demasiado largo.\n"
"Solo %d chars MAX\n", STROZO - 2 );
exit(1);
}
else
*(ArchivoDestino + strlen( ArchivoDestino ) -1 ) = '\0';

if( ( ADest = fopen( ArchivoDestino, "a" ) ) == NULL )
{
fprintf( stderr, "No puedo abrir %s\n", ArchivoDestino );
exit( 2 );
}

if( setvbuf( ADest, NULL, _IOFBF, BUFTAMANO ) != 0 )
{
fputs( "No puedo crear el buffer de salida\n", stderr );
exit( 3 );
}

puts( "Ingresa el nombre del primer archivo de fuente (Línea vacio para terminar):" );
while( fgets( ArchivoFuente, STROZO - 2, stdin ) && ArchivoFuente[0] != '\n' )
{
if( *(ArchivoFuente + strlen( ArchivoFuente ) -1 ) != '\n' )
{
printf( "El nombre que entraste es demasiado largo.\n"
"Solo %d chars MAX\n", STROZO - 2 );
exit(1);
}
else
*(ArchivoFuente + strlen( ArchivoFuente ) -1 ) = '\0';

if( strcmp( ArchivoFuente, ArchivoDestino ) == 0 )
fputs( "No puedo usar el mismo archivo por fuente y destino\n", stderr );
else if( ( AFuente = fopen( ArchivoFuente, "r" ) ) == NULL )
fprintf( stderr, "No puedo abrir %s\n", ArchivoFuente );
else
{
if( setvbuf( AFuente, NULL, _IOFBF, BUFTAMANO ) != 0 )
{
fputs( "No puedo crear el buffer de ingreso\n", stderr );
continue;
}
append( AFuente, ADest );
if( ferror( AFuente ) != 0 )
fprintf( stderr, "Error en leer el archivo %s.\n", ArchivoFuente );
if( ferror( ADest ) != 0 )
fprintf( stderr, "Error in escribir el archivo file %s.\n", ArchivoDestino );
fclose( AFuente );
Archivos++;
printf( "Archivo %s agregado.\n", ArchivoFuente );
puts( "Siguiente archivo (Línea vacio para terminar):" );
}
}
printf( "Listo. %d archivos agregados.\n", Archivos );
fclose( ADest );

return 0;
}

void append( FILE *Fuente, FILE *dest )
{
size_t bytes;
static char temp[BUFTAMANO]; // allocate once
while( ( bytes = fread( temp, sizeof( char ), BUFTAMANO, Fuente ) ) > 0 )
fwrite( temp, sizeof (char), bytes, dest );
}
</syntaxhighlight>

=== Resultado ===
<pre>
[rrc@llawyr CClase]$ gcc -Wall -o Prog115 Prog115.c
[rrc@llawyr CClase]$ ./Prog115
Ingresa el nombre del archivo de destino: Dest
Ingresa el nombre del primer archivo de fuente (Línea vacio a terminar):
Prog1.c
Archivo Prog1.c agregado.
Siguiente archivo (Línea vacio para terminar):
Prog2.c
Archivo Prog2.c agregado.
Siguiente archivo (Línea vacio para terminar):
Prog3.c
Archivo Prog3.c agregado.
Siguiente archivo (Línea vacio para terminar):

Listo. 3 archivos agregados.
[rrc@llawyr CClase]$ cat Dest
/* Prog4.c -- Asignación de resultados aritméticos */
#include <stdio.h>

int main( void )
{
int n = 5,
n2 = n * n,
n3 = n2 * n; /* decleración y asignación de resultado de multiplicación */

printf( "n = %d, n cuadrado = %d, n cubo = %d\n", n, n2, n3 );
return 0;
}
/* Prog5.c -- floats y scanf() */

#include <stdio.h>

int main(void)
{
float peso;

printf("¿Vale usted su peso en rhodium?\n");
printf("Vamos a ver.\n");
printf("Ingrese su peso en libras: ");

/* Obtener peso del usuario */
scanf("%f", &peso);

/* Si rhodium vale $770 el once */
/* 14.5833 para convertir pounds avd. a ounces troy */

printf("Su peso en rhodium vale $%.2f.\n", (770.0 * peso * 14.5833) );
printf("Si el valor de rhodium baja,\n");
printf("come más a mantener su valor.\n");

return 0;
}

// Prog1.c
#include <stdio.h>

int main(void) /* Un programa simple */
{
int num; /* definir una variable llamada num */
num = 1; /* asignar una valor a num */

printf("Soy una computadora "); /* use the printf() function */
printf("simple.\n");
printf("Mi número favorito es %d porque el es el primer.\n", num);
return 0;
}

/* Prog2.c */

#include <stdio.h>

int main (void)
{
int fathoms = 2,
feet = 6 * fathoms;

printf("Son %d pies en %d fathoms!\n", feet, fathoms);
return 0;
}

// Prog3.c
#include <stdio.h>

void macero( void ); /* Prototipo de la función macero() */

int main(void)
{
printf( "Voy a convocar el macero.\n" );
macero();
printf( "Si. Me traen algunos DVDs grabables y té.\n" );
return 0;
}

void macero(void) /* Definición de la función macero() */
{
printf( "Me llamaste, señor?\n" );
}
[rrc@llawyr CClase]$
</pre>

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog114

2014-06-03T20:16:56Z

Perseuz: /* Prog114 */

__NOTOC__
* [[:#Prog114 | fseek(), ftell() y fopen con "rb" ]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog114 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define CNTL_Z '\032' /* eof marker in DOS text files */
#define SLEN 50

int main( void )
{
char file[SLEN],
ch;

FILE *fp;

long count,
last;

printf( "Escribe el nombre del archivo a usar: ");
fgets( file, SLEN - 2, stdin );

if( *(file + strlen( file ) -1 ) != '\n' )
{
printf( "El nombre que entraste es demasiado largo.\n"
"Solo %d chars MAX\n", SLEN - 2 );
exit(1);
}
else
*(file + strlen( file ) -1 ) = '\0';

if( ( fp = fopen( file, "rb" ) ) == NULL )
{
printf( "No puedo abrir el archivo %s\n", file );
exit( 1 );
}

fseek( fp, 0L, SEEK_END );
last = ftell( fp );

for( count = 1L; count <= last; count++ )
{
fseek( fp, -count, SEEK_END ); /* Leer en reversa SEEK_CUR SEEK_SET */
ch = getc( fp );
if( ch != CNTL_Z && ch != '\r' )
putchar( ch );
}

putchar( '\n' );
fclose( fp );

return 0;
}

</syntaxhighlight>

=== Resultado ===
<pre>
[rrc@llawyr CClase]$ gcc -Wall -o Prog114 Prog114.c
[rrc@llawyr CClase]$ ./Prog114
Escribe el nombre del archivo a usar: MiArchivo
No puedo abrir el archivo MiArchivo
[rrc@llawyr CClase]$ ./Prog114
Escribe el nombre del archivo a usar: Prog1.c

}
;0 nruter
;)mun ,"n\.remirp le se le euqrop d% se otirovaf orem��n iM"(ftnirp
;)"n\.elpmis"(ftnirp
/* noitcnuf )(ftnirp eht esu */ ;)" arodatupmoc anu yoS"(ftnirp

/* mun a rolav anu rangisa */ ;1 = mun
/* mun adamall elbairav anu rinifed */ ;mun tni
{
/* elpmis amargorp nU */ )diov(niam tni

>h.oidts< edulcni#
</pre>

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog113

2014-06-03T16:34:33Z

Perseuz: /* Prog113 */

__NOTOC__
* [[:#Prog113 | fgets() y fputs()]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog113 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">
#include <stdio.h>

#define MAXLINEA 20

int main(void)
{
char Linea[MAXLINEA];

while( fgets( Linea, MAXLINEA - 1, stdin ) != NULL && Linea[0] != '\n' )
fputs( Linea, stdout );

return 0;
}

</syntaxhighlight>

=== Resultado ===
<pre>
[rrc@llawyr CClase]$ gcc -Wall -o Prog113 Prog113.c
[rrc@llawyr CClase]$ ./Prog113
Aquí podemos ver que la combinación de fputs() y fgets() sirven bien.
Aquí podemos ver que la combinación de fputs() y fgets() sirven bien.
El fgets() guarda el retorno de carro y el fputs() no agrega un returno de carro al fin.
El fgets() guarda el retorno de carro y el fputs() no agrega un returno de carro al fin.

[rrc@llawyr CClase]$
</pre>

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog112

2014-06-03T16:18:25Z

Perseuz: /* Prog112 */

__NOTOC__
* [[:#Prog112 | fopen() con a+ y rewind()]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog112 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

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

#define MAX 40

int main( void )
{
FILE *fp;

char Palabras[MAX];

if( ( fp = fopen( "Palabras", "a+" ) ) == NULL )
{
fprintf( stderr, "No puedo abrir \"Palabras\" archivo.\n");
exit(1);
}

puts( "Ingresa las palabras que quieres agregar en el archivo." );
puts( "Retorno de carrito al inicio de la línea para terminar" );

while( gets( Palabras ) != NULL && Palabras[0] != '\0' )
fprintf( fp, "%s ", Palabras );

puts( "Contenidos del archivo:" );
rewind( fp );

while( fscanf( fp, "%s", Palabras ) == 1 )
puts( Palabras );

if( fclose( fp ) != 0 )
{
fprintf( stderr, "Error: No puedo cerrar el archivo\n" );
exit(1);
}
return 0;
}

</syntaxhighlight>

=== Resultado ===
<pre>
[rrc@llawyr CClase]$ gcc -Wall -o Prog112 Prog112.c
[rrc@llawyr CClase]$ ./Prog112
Ingresa las palabras que quieres agregar en el archivo.
Retorno de carrito al inicio de la línea para terminar
Son mis palabras

Contenidos del archivo:
Son
mis
palabras
[rrc@llawyr CClase]$ ./Prog112
Ingreso las palabras que quieres agregar en el archivo.
Retorno de carrito al inicio de la línea a terminar
Son más de mis palabras

Contenidos del archivo:
Son
mis
palabras
Son
más
de
mis
palabras
[rrc@llawyr CClase]$
</pre>

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog82

2014-06-03T15:10:31Z

Perseuz: /* Explicación */

__NOTOC__
* [[:#Prog82 | fgets()]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog82 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

#includ#include <stdio.h>

#define MAX 5

int main( void )
{
char nombre[MAX];
char * ptr;

printf( "Hola, cómo se llama usted?\n" );

ptr = fgets( nombre, MAX, stdin );
printf( "%s? Ah! %s!\n", nombre, ptr );

return 0;
}

</syntaxhighlight>

=== Resultado ===

[rrc@llawyr CClase]$ gcc -Wall -o Prog82 Prog82.c
[rrc@llawyr CClase]$ ./Prog82
Hola, cómo se llama usted?
Richard
Richard
? Ah! Richard
!

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]
Ver una explicación detallada de la función en https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C/Manejo_de_archivos#fgets

Curso de Programación en C/Mode Strings De fopen()

2014-06-02T21:45:25Z

Perseuz: /* Mode Strings De fopen() */

__NOTOC__
* [[:#Mode Strings De fopen() | Mode Strings De fopen()]]
** [[:#Explicación | Explicación]]

== Mode Strings De fopen() ==

<table cellpadding="1" cellspacing="12">
<tr>
<th>String</th><th>Explicación</th>
</tr>
<tr style=text-align:center;>
<td>"r"</td><td>Abrir archivo de texto para leer</td>
</tr>
<tr style=text-align:center;>
<td>"w"</td><td>Abrir un archivo de texto para escribir.<br />Si existe el archivo se trunca.<br />Si el archivo no existe, se crea.</td>
</tr>
<tr style=text-align:center;>
<td>"a"</td><td>Abrir un archivo de texto para escribir al final del archivo.<br />Si el archivo no existe, se crea.</td>
</tr>
<tr style=text-align:center;>
<td>"r+"</td><td>Abrir un archivo de texto para leer y para escribir.<br />No se borran los contenidos del archivo si existe.<br />Si el archivo no existe, se crea.</td>
</tr>
<tr style=text-align:center;>
<td>"w+"</td><td>Abrir un archivo de texto para leer y para escribir.<br />Se borran todos los contenidos del archivo si existe.<br />Si el archivo no existe, se crea.</td>
</tr>
<tr style=text-align:center;>
<td>"a+"</td><td>Como "r+" pero escribir se permite solo al final del archivo</td>
</tr>
<tr style=text-align:center;>
<td>"rb", "wb", "ab"<br />"ab+", "a+b", "wb+"<br />"w+b", "ab+", "a+b"</td><td>Como los anteriores pero en modo binario</td>
</tr>
</table>

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog109

2014-06-02T19:33:17Z

Perseuz: /* Prog109 */

__NOTOC__
* [[:#Prog109 | malloc(), free(), exit() & strtod()]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog109 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

#include <stdio.h>
#include <stdlib.h> /* for malloc(), free() */
#include <string.h>

int main( void )
{
double * ptd;

char NumSTR[10];

char * endptr;

int i = 0,
Max,
NumCharsLeidos,
NumEntradas,
NumPuntos,
NumValidosChars,
Numero;

printf( "¿Cuál es el máximo número de dobles que vamos a guardar? " );

fgets( NumSTR, 4, stdin );
NumValidosChars = 0;
if( ( NumCharsLeidos = strlen( NumSTR ) ) > 4 )
{
puts( "Entrada ¡INVALIDO!\nDebe ser menor que 99" );
exit( 1 );
}

if( NumSTR[0] == '0' )
{
puts( "Debemos guardar un mínimo de 1 double" );
exit( 1 );
}

if( *(NumSTR + NumCharsLeidos - 1) != '\n' )
{
puts( "Entrada ¡INVALIDO!\nDebe ser menor que 99" );
exit( 1 );
}
else
*(NumSTR + NumCharsLeidos - 1) = '\0';

for( i = 0; i < NumCharsLeidos -1; i++ )
if( ( *(NumSTR + i ) >= '0' && *(NumSTR + i ) <= '9' ) )
NumValidosChars++;

if( NumCharsLeidos == 1 || NumValidosChars != NumCharsLeidos - 1 )
{
puts( "Entrada ¡INVALIDO!" );
exit( 1 );
}
Max = atoi( NumSTR );

ptd = (double *)malloc( Max * sizeof( double ) );

if( ptd == NULL )
{
puts( "Falló la asignación de memoria. Adiós." );
exit( EXIT_FAILURE );
}

puts( "Ingresa los dobles (q para terminar):" );

NumEntradas = 0;

while( ( NumEntradas < Max ) && fgets( NumSTR, 8, stdin ) )
{
NumValidosChars = 0;
NumCharsLeidos = strlen( NumSTR );

if( NumSTR[0] == 'q' && NumCharsLeidos == 2 )
break;

if( *(NumSTR + NumCharsLeidos - 1) != '\n' )
{
puts( "Entrada ¡INVALIDO! (Tan Grande - No más que 6 chars)" );
while( getchar() != '\n' );
puts( "Ingresa los dobles:" );
continue;
}
else
*(NumSTR + NumCharsLeidos - 1) = '\0';

NumPuntos = 0;

for( i = 0; i < NumCharsLeidos -1; i++ )
if( ( *(NumSTR + i ) >= '0' && *(NumSTR + i ) <= '9' ) ||
( *(NumSTR) == '-' && i == '0' ) ||
( *(NumSTR + i ) == '.' && ++NumPuntos < 2 ) )
NumValidosChars++;

if( NumCharsLeidos == 1 || NumValidosChars != NumCharsLeidos - 1 )
{
puts( "Entrada ¡INVALIDO!" );
puts( "Ingresa los dobles:" );
continue;
}
ptd[NumEntradas++] = strtod( NumSTR, &endptr );
}

printf( "\nAquí son sus %d dobles:\n", Numero = NumEntradas );

for( i = 0; i < Numero; i++ )
{
printf("%7.2f ", ptd[i]);

if( i % 7 == 6 )
putchar( '\n' );
}

if( i % 7 != 0 )
putchar( '\n' );

puts("¡Listo!");
free(ptd);

return 0;
}

</syntaxhighlight>

=== Resultado ===
<pre>
[rrc@llawyr CClase]$ gcc -Wall -o Prog109 Prog109.c
[rrc@llawyr CClase]$ ./Prog109
¿Cuál es el máximo número de dobles que vamos a guardar? 25
Ingresa los dobles (q para terminar):
q

Aquí son sus 0 dobles:
¡Listo!
[rrc@llawyr CClase]$ ./Prog109
¿Cuál es el máximo número de dobles que vamos a guardar? 25
Ingresa los dobles (q para terminar):
23
-23
23.456
-23.456
Entrada ¡INVALIDO! (Tan Grande - No más que 6 chars)
Ingresa los dobles:
-23.45
123456
-123456
Entrada ¡INVALIDO! (Tan Grande - No más que 6 chars)
Ingresa los dobles:
-12345

Entrada ¡INVALIDO!
Ingresa los dobles:

Entrada ¡INVALIDO!
Ingresa los dobles:
quit
Entrada ¡INVALIDO!
Ingresa los dobles:
8765.2
45.67
-53.4.4
Entrada ¡INVALIDO! (Tan Grande - No más que 6 chars)
Ingresa los dobles:
5.3.2
Entrada ¡INVALIDO!
Ingresa los dobles:
54-3
Entrada ¡INVALIDO!
Ingresa los dobles:
66
q

Aquí son sus 9 dobles:
23.00 -23.00 23.46 -23.45 123456.00 -12345.00 8765.20
45.67 66.00
¡Listo!
</pre>

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog105

2014-06-01T15:12:57Z

Perseuz: /* Prog105 */

__NOTOC__
* [[:#Prog105 | Multiples Archivos]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog105 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

//Archivo Prog105a.c
#include <stdio.h>

void InformeDelConteo( void );
extern void acumularse( int );

int Contar = 0;

int main(void)
{
int Valor;
register int i;

printf( "Ingresa un número entero positivo (0 a terminar): " );

while( scanf( "%d", &Valor ) == 1 && Valor > 0 ) // mientras que scanf() lea un dato y este sea positivo
{
++Contar;

for( i = Valor; i >= 0; i-- )
acumularse(i);
printf( "Ingresa un número entero positivo (0 a terminar): ");
}
InformeDelConteo(); // scanf() recibe un dato negativo o cero

return 0;
}

void InformeDelConteo( void )
{
printf( "El while loop fue ejecutado %d veces\n", Contar );
}

// Archivo Prog105b.c
#include <stdio.h>

extern int Contar;
static int total = 0;

void acumularse( int k )
{
static int subtotal = 0;

if( k <= 0 )
{
printf( "ciclo de loop: %d\n", Contar );
printf( "subtotal: %d; total: %d\n", subtotal, total );
subtotal = 0;
}
else
{
subtotal += k;
total += k;
}
}

</syntaxhighlight>

=== Resultado ===
<pre>
[rrc@llawyr CClase]$ gcc -Wall -o Prog105 Prog105a.c Prog105b.c
[rrc@llawyr CClase]$ ./Prog105
Ingresa un númenro entero positivo (0 a terminar): 1
ciclo de loop: 1
subtotal: 1; total: 1
Ingresa un númenro entero positivo (0 a terminar): 1
ciclo de loop: 2
subtotal: 1; total: 2
Ingresa un númenro entero positivo (0 a terminar): 2
ciclo de loop: 3
subtotal: 3; total: 5
Ingresa un númenro entero positivo (0 a terminar): 2
ciclo de loop: 4
subtotal: 3; total: 8
Ingresa un númenro entero positivo (0 a terminar): 3
ciclo de loop: 5
subtotal: 6; total: 14
Ingresa un númenro entero positivo (0 a terminar): 3
ciclo de loop: 6
subtotal: 6; total: 20
Ingresa un númenro entero positivo (0 a terminar): 4
ciclo de loop: 7
subtotal: 10; total: 30
Ingresa un númenro entero positivo (0 a terminar): 0
El while loop fue ejecutado 7 veces
[rrc@llawyr CClase]$
</pre>

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog68

2014-05-30T16:05:02Z

Perseuz: /* Prog68 */

__NOTOC__
* [[:#Prog68 | Más restricciónes locales]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog68 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

#include <stdio.h>

void intercambio( int u, int v );

int main( void )
{
int x = 5,
y = 10;

printf( "Originalmente x = %d e y = %d.\n", x , y );
intercambio( x, y );
printf( "En main(), Después de intercambio( x, y ) x = %d e y = %d.\n",
x, y );

return 0;
}

void intercambio( int u, int v )
{
int temp;

printf( "Inicialmente en intercambio u = %d y v = %d.\n", u , v );
temp = u;
u = v;
v = temp;
printf( "En intercambio(), Después de intercambiar u = %d y v = %d.\n",
u, v );
}

</syntaxhighlight>

=== Resultado ===

[rrc@Pridd CClase]$ gcc -Wall -O2 -o Prog68 Prog68.c
[rrc@Pridd CClase]$ ./Prog68
Originalmente x = 5 e y = 10.
Inicialmente en intercambio u = 5 y v = 10.
En intercambio(), Después de intercambiar u = 10 y v = 5.
En main(), Después de intercambio( x, y ) x = 5 e y = 10.

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog100

2014-05-28T18:04:15Z

Perseuz: /* Prog100 */

__NOTOC__
* [[:#Prog100 | strtol()]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog100 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

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

int main( void )
{
char numero[30];
char * Fin;
long Valor;

printf( "Ingresa un número (Returno de carro para terminar): " );

while( fgets( numero, 29, stdin ) && numero[0] != '\n' )
{
*(numero + ( strlen( numero ) -1 )) = '\0';

Valor = strtol( numero, &Fin, 10 ); /* base 10 */
printf( "Valor: %ld, terminado a %s (%d)\n",
Valor, Fin, *Fin );
Valor = strtol( numero, &Fin, 16 ); /* base 16 */
printf( "Valor: %ld, terminado a %s (%d)\n",
Valor, Fin, *Fin );
printf( "Siguiente numero: " );
}
puts( "\n¡Adios!\n" );
return 0;
}

</syntaxhighlight>

=== Resultado ===
<pre>
[rrc@llawyr CClase]$ gcc -Wall -o Prog100 Prog100.c
[rrc@llawyr CClase]$ ./Prog100
Ingresa un número (Returno de carro para terminar): 46
Valor: 46, terminado a (0)
Valor: 70, terminado a (0)
Siguiente numero: 356.7
Valor: 356, terminado a .7 (46)
Valor: 854, terminado a .7 (46)
Siguiente numero: -87
Valor: -87, terminado a (0)
Valor: -135, terminado a (0)
Siguiente numero: 765iu45
Valor: 765, terminado a iu45 (105)
Valor: 1893, terminado a iu45 (105)
Siguiente numero:
Ingresa un número (Returno de carro para terminar): 24abcg
Valor: 24, terminado a abcg (97)
Valor: 150204, terminado a g (103)
Siguiente numero:

¡Adios!

[rrc@llawyr CClase]$
</pre>
=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog89

2014-05-21T16:23:50Z

Perseuz: /* Prog89 */

__NOTOC__
* [[:#Prog89 | strcmp()]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog89 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

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

#define PAIS "India"

void ObtenRespuesta( void );

char respuesta[40];

int main( void )
{
printf( "En que pais es el Taj Mahal? " );
ObtenRespuesta();

while( strcmp( respuesta, PAIS ) ) //strcmp(): Compara dos strings
{
printf( "No, incorrecto. Otra ves: " );
ObtenRespuesta();
}
puts( "¡Correcto!" );

return 0;
}

void ObtenRespuesta( void )
{
fgets( respuesta, 37, stdin );
if( *(respuesta + strlen( respuesta ) - 1) == '\n' )
*(respuesta + strlen( respuesta ) - 1) = '\0';
}

</syntaxhighlight>

=== Resultado ===

[rrc@llawyr CClase]$ gcc -Wall -o Prog89 Prog89.c
[rrc@llawyr CClase]$ ./Prog89
En que pais es el Taj Mahal? Italia
No, incorrecto. Otra ves: Grecia
No, incorrecto. Otra ves: india
No, incorrecto. Otra ves: India
¡Correcto!
[rrc@llawyr CClase]$

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog88

2014-05-21T16:17:06Z

Perseuz: /* Resultado */

__NOTOC__
* [[:#Prog88 | Prog87 con fgets()]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog88 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

#include <stdio.h>
#include <string.h> /* para usar strcat() */

#define TAMANO 80

int main( void )
{
char flor[TAMANO],
agregado[] = "s huelen como zapatos viejos.";

printf( "¿Cuál es su flor preferida? " );
fgets( flor, 51, stdin ); // char *fgets(char *s, int n, FILE *flujo): Toma un string
// de un flujo
*(flor + strlen( flor ) - 1 ) = '\0'; // strlen(): Calcula la longitud de un string
strcat( flor, agregado );
puts( flor );

return 0;
}

</syntaxhighlight>

=== Resultado ===

[rrc@llawyr CClase]$ gcc -Wall -o Prog88 Prog88.c
[rrc@llawyr CClase]$ ./Prog88
¿Cuál es su flor preferida? Rosa
Rosas huelen como zapatos viejos.
[rrc@llawyr CClase]$

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog87

2014-05-21T16:12:37Z

Perseuz: /* Prog87 */

__NOTOC__
* [[:#Prog87| strcat()]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog87 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

#include <stdio.h>
#include <string.h> /* para usar strcat() */

#define TAMANO 80

int main( void )
{
char flor[TAMANO],
agregado[] = "s huelen como zapatos viejos.";

printf( "¿Cuál es su flor preferida? " );
gets( flor );
strcat( flor, agregado ); //strcat() Añade un string a otro
puts( flor );

return 0;
}

</syntaxhighlight>

=== Resultado ===

[rrc@llawyr CClase]$ gcc -Wall -o Prog87 Prog87.c
[rrc@llawyr CClase]$ ./Prog87
¿Cuál es su flor preferida? Anthurium
Anthuriums huelen como zapatos viejos.
[rrc@llawyr CClase]$

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog77

2014-05-20T01:26:46Z

Perseuz: /* Resultado */

__NOTOC__
* [[:#Prog77 | Arregle de tamaños variables]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog77 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

#include <stdio.h>

#define FILAS 3
#define COLS 4

int sum2d( int rows, int cols, int ar[rows][cols] );

int main( void )
{
int cs = 10,
i,
j,
junk[FILAS][COLS] = {
{2,4,6,8},
{3,5,7,9},
{12,10,8,6}
},
masjunk[FILAS-1][COLS+2] = {
{20,30,40,50,60,70},
{5,6,7,8,9,10}
},
rs = 3,
varr[rs][cs];

for( i = 0; i < rs; i++ )
for( j = 0; j < cs; j++ )
varr[i][j] = i * j + j;

printf( "3x5 arreglo\n" );
printf( "Sum de todos los elementos = %d\n",
sum2d( FILAS, COLS, junk ) );

printf( "2x6 arreglo\n" );
printf( "Sum de todos los elementos = %d\n",
sum2d( FILAS-1, COLS+2, masjunk ) );

printf( "3x10 VLA\n" );
printf( "Sum de todos los elementos = %d\n",
sum2d( rs, cs, varr ) );

return 0;
}

int sum2d( int rows, int cols, int ar[rows][cols] )
{
int r;
int c;
int tot = 0;

for( r = 0; r < rows; r++ )
for( c = 0; c < cols; c++ )
tot += ar[r][c];

return tot;
}

</syntaxhighlight>

=== Resultado ===

[rrc@Pridd CClase]$ gcc -Wall -O2 -o Prog77 Prog77.c
[rrc@Pridd CClase]$ ./Prog77
3x5 arreglo
Sum de todos los elementos = 80
2x6 arreglo
Sum de todos los elementos = 315
3x10 VLA
Sum de todos los elementos = 270
[rrc@Pridd CClase]$

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

La asignación de los elementos del arreglo varr = [rs][cs] queda así:

for( i = 0; i < rs; i++ )
for( j = 0; j < cs; j++ )
varr[i][j] = i * j + j;

igual a:

varr = [3][10] = { { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },{ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18 },{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27 } }

Curso de Programación en C/Prog66

2014-05-10T18:09:47Z

Perseuz: /* Explicación */

__NOTOC__
* [[:#Prog66 | Función Recursivo]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog66 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

#include <stdio.h>

void a_binario( unsigned long n );

int main( void )
{
unsigned long numero;
printf( "Que intero quieres convertir en binario (q para terminar)? " );
while( scanf( "%lu", &numero ) == 1 )
{
printf("Equivalente Binario: ");
a_binario( numero );
putchar( '\n' );
putchar( '\n' );
printf( "Que intero quieres convertir en binario (q para terminar)? " );
}
printf( "Listo.\n" );

return 0;
}

void a_binario( unsigned long n )
{
int r;

r = n % 2;
if ( n >= 2 )
a_binario( n / 2 );
putchar( '0' + r );

return;
}

</syntaxhighlight>

=== Resultado ===

[rrc@Pridd CClase]$ gcc -Wall -O2 -o Prog66 Prog66.c
[rrc@Pridd CClase]$ ./Prog66
Que intero quieres convertir en binario (q para terminar)? 1
Equivalente Binario: 1

Que intero quieres convertir en binario (q para terminar)? 2
Equivalente Binario: 10

Que intero quieres convertir en binario (q para terminar)? 3
Equivalente Binario: 11

Que intero quieres convertir en binario (q para terminar)? 4
Equivalente Binario: 100

Que intero quieres convertir en binario (q para terminar)? 5
Equivalente Binario: 101

Que intero quieres convertir en binario (q para terminar)? 55
Equivalente Binario: 110111

Que intero quieres convertir en binario (q para terminar)? 44444555
Equivalente Binario: 10101001100010101110001011

Que intero quieres convertir en binario (q para terminar)? q
Listo.

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]
Ejemplo para el número 4: El truco está en seguir el flujo de control hasta volver a main(). Notece que la variable r de uno a otro bloque, aunque se llama igual no es la misma. Se crea en cada bloque, posee su propia dirección de memoria y no es sobreescrita por la calculada en otro bloque.

n = 4: <-------- Viene de main()

a_binario (4) --------> n = 4
{
int r;
r = 4 % 2; --------> r = 0
if (4 >= 2) <-- Verdadero

a_binario (4/2) --------> n = 2
{
int r;
r = 2 % 2; --------> r = 0
if (2 >= 2) <-- Verdadero

a_binario (2/2) --------> n = 1
{
int r;
r = 1 % 2; --------> r = 1
if (1 >= 2) <-- Falso
putchar('0' + 1)--------> Imprime 1
return;
}

putchar('0' + 0)--------> Imprime 0
return;
}

putchar('0' + 0)--------> Imprime 0
return;
} <-------- Vuelve el control a main()

Impresión final: 100

Curso de Programación en C/Prog57

2014-05-02T21:25:41Z

Perseuz: /* Resultado */

__NOTOC__
* [[:#Prog57 | Validación de ingreso]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog57 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

#include <stdio.h>
#include <stdbool.h>

int obten_int( void ); // Validar que ingreso es int
bool mal_limites( int inicia, int termina, int bajo, int alto );
double suma_cuadrados( int a, int b );

int main( void )
{
const int MIN = -1000;
const int MAX = +1000;
int inicio;
int termina;
double respuesta;

printf( "Este programa calcula la suma de los cuadrados de enteros\n"
"en un rango entre -1000 y +1000.\n"
"Entra los limites (0 en los dos limites para terminar)\n"
"Limite bajo: " );
inicio = obten_int();
printf( "Limite alto: " );
termina = obten_int();
while( inicio !=0 || termina != 0 )
{
if( mal_limites( inicio, termina, MIN, MAX ) )
printf( "Otra vez por favor.\n" );
else
{
respuesta = suma_cuadrados( inicio, termina );
printf( "La suma de los cuadrados de los enteros " );
printf( "entre %d y %d es %g\n", inicio, termina, respuesta );
}
printf( "Entra los limites (0 en los dos "
"para terminar)\n" );
printf( "limite bajo: " );
inicio = obten_int();
printf( "limite alto: " );
termina = obten_int();
}
printf( "Listo.\n" );

return 0;
}

int obten_int( void )
{
int ingreso;
char ch;

while( scanf( "%d", &ingreso ) != 1)
{
while( ( ch = getchar() ) != '\n' )
putchar( ch );
printf( " no es un entero.\nFavor entrar un " );
printf( "entero cómo 25, -178, o 3: " );
}

return ingreso;
}

double suma_cuadrados( int a, int b )
{
double total = 0;
int i;

for( i = a; i <= b; i++ )
total += i * i;

return total;
}

bool mal_limites( int inicio, int termina, int bajo, int alto )
{
bool no_bueno = false;

if( inicio > termina )
{
printf( "%d no es menor que %d.\n", inicio, termina );
no_bueno = true;
}

if( inicio < bajo || termina < bajo )
{
printf( "Valores deben ser >= %d.\n", bajo );
no_bueno = true;
}

if( inicio > alto || termina > alto )
{
printf( "Valores deben ser <= %d.\n", alto );
no_bueno = true;
}

return no_bueno;
}

</syntaxhighlight>

=== Resultado ===

[rrc@Pridd CClase]$ gcc -Wall -O2 -o Prog57 Prog57.c
[rrc@Pridd CClase]$ ./Prog57
Este programa calcula la suma de los cuadrados de enteros
en un rango entre -1000 y +1000.
Entra los limites (0 en los dos limites para terminar)
Limite bajo: 4r
limite alto: r no es un entero.
Favor a entrar un entero cómo 25, -178, o 3: 999
La suma de los cuadrados de los enteros entre 4 y 999 es 3.32833e+08
Entra los limites (0 en los dos para terminar)
limite bajo: 45
limite alto: 33
45 no es menor que 33.
Otra vez por favor.
Entra los limites (0 en los dos para terminar)
limite bajo: 999
limite alto: 2000
Valores deben ser <= 1000.
Otra ves por favor.
Entra los limites (0 en los dos para terminar)
limite bajo: -1200
limite alto: 3
Valores deben ser >= -1000.
Otra vez por favor.
Entra los limites (0 en los dos para terminar)
limite bajo: 3
limite alto: 4
La suma de los cuadrados de los enteros entre 3 y 4 es 25
Entra los limites (0 en los dos para terminar)
limite bajo: -3
limite alto: 3
La suma de los cuadrados de los enteros entre -3 y 3 es 28
Entra los limites (0 en los dos para terminar)
limite bajo: 0
limite alto: 0
Listo.
[rrc@Pridd CClase]$

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]
Linea 50. scanf() != 1: significa q ingreso no ha sido asignado pq el texto ingresado no coincide con un entero.

Curso de Programación en C/Prog56

2014-05-02T15:02:38Z

Perseuz: /* Explicación */

__NOTOC__
* [[:#Prog56 | Leer un Archivo]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog56 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

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

int main( void )
{
int ch;
FILE * fp;
char NArchivo[50];

printf("¿Que archivo quieres ver? ");
scanf("%s", NArchivo);

if( ( fp = fopen(NArchivo, "r") ) == NULL )
{
printf( "No puedo abrir %s\n", NArchivo );
exit(1);
}

while( ( ch = getc( fp ) ) != EOF )
putchar( ch );
fclose( fp );

return 0;
}

</syntaxhighlight>

=== Resultado ===

¿Que archivo quieres ver? Prog56.c
#include <stdio.h>
#include <stdlib.h>

int main( void )
{
int ch;
FILE * fp;
char NArchivo[50];

printf("¿Que archivo quieres ver? ");
scanf("%s", NArchivo);

if( ( fp = fopen(NArchivo, "r") ) == NULL )
{
printf( "No puedo abrir %s\n", NArchivo );
exit(1);
}

while( ( ch = getc( fp ) ) != EOF )
putchar( ch );
fclose( fp );

return 0;
}

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Para Windows, el archivo Prog01.c que vamos a abrir, debe estar en la carpeta donde se encuentra Prog56.c
El formato de fopen es: fp = fopen(nombre, modo) . En el "nombre" puede especificar un path o ruta donde se encuentra el archivo.

Curso de Programación en C/Prog49

2014-04-30T15:37:17Z

Perseuz: /* Prog49 */

__NOTOC__
* [[:#Prog49 | Funciones para probar un caracter]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog49 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

#include <stdio.h>

int main( void )
{
printf( " Nombre Verdad si su argumento es\n\n"
" isalnum() Alfanumerico\n"
" isalpha() Alfabetico\n"
" isblank() caracter vacio como \' \', \'<tab>\', \'\\n\'\n"
" iscntrl() caracter de control como \'<Ctrl+B>\'\n"
" isdigit() un numeral (\'0\' - \'9\')\n"
" isgraph() un caracter que escribe algo que no es \' \'\n"
" islower() una minuscula\n"
" isprint() que imprime algo en la pantalla\n"
" ispunct() imprime algo que NO es \' \' , o alfanumerico\n"
" isspace() un caracter de espacio blanco\n"
" isupper() una mayuscula\n"
" isxdigit() un numeral hexadecimal\n\n" );
return 0;
}

</syntaxhighlight>

=== Resultado ===

[rrc@Pridd CClase]$ gcc -Wall -O2 -o Prog49 Prog49.c
[rrc@Pridd CClase]$ ./Prog49

Nombre Verdad si su argumento es

isalnum() Alfanumerico
isalpha() Alfabetico
isblank() caracter vacio como ' ', '<tab>', '\n'
iscntrl() caracter de control como '<Ctrl+B>'
isdigit() un numeral ('0' - '9')
isgraph() un caracter que escribe algo que no es ' '
islower() una minuscula
isprint() que imprime algo en la pantalla
ispunct() imprime algo que NO es ' ' , o alfanumerico
isspace() un caracter de espacio blanco
isupper() una mayuscula
isxdigit() un numeral hexadecimal

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog24

2014-04-26T01:31:56Z

Perseuz: /* Prog24 */

__NOTOC__
* [[:#Prog24 | Prog24]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog24 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

/* Prog24.c - Salta algunas entradas */

#include <stdio.h>

int main( void )
{
int n;

printf( "Ingresa tres (3) enteros por favor:\n" );
scanf( "%*d %*d %d", &n );
printf( "El ultimo entero fue %d\n", n );

return 0;
}

</syntaxhighlight>

=== Resultado ===

[rrc@Pridd CClase]$ gcc -Wall -O2 -o Prog24 Prog24.c
[rrc@Pridd CClase]$ ./Prog24
Ingresa tres (3) enteros por favor:
23 -44 944
El ultimo entero fue 944

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog21

2014-04-25T19:05:36Z

Perseuz: /* Prog21 */

__NOTOC__
* [[:#Prog21 | Prog21]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog21 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

/* Prog21.c -- Valor regresado por printf() */

#include <stdio.h>

int main( void )
{
int EbullicionH2O = 100,
ValorRegresado;

ValorRegresado = printf( "%dC es el punto de ebullicion del agua.\n", EbullicionH2O );
printf( "12345678901234567890123456789012345\n" );
printf( "La funcion printf() escribio %d caracteres.\n", ValorRegresado );

return 0;
}

</syntaxhighlight>

=== Resultado ===

[rrc@Pridd CClase]$ gcc -Wall -O2 -o Prog21 Prog21.c
[rrc@Pridd CClase]$ ./Prog21
100C es el punto de ebullicion del agua.
12345678901234567890123456789012345
La funcion printf() escribio 41 caracteres.
[rrc@Pridd CClase]$

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]

Curso de Programación en C/Prog18

2014-04-25T15:31:48Z

Perseuz: /* Prog18 */

__NOTOC__
* [[:#Prog18 | Prog18]]
** [[:#Resultado | Resultado]]
** [[:#Explicación | Explicación]]

== Prog18 ==

<syntaxhighlight lang="c" line="GESHI_FANCY_LINE_NUMBERS">

/* Prog18.c -- flags con strings */

#include <stdio.h>

#define BLURB "Imitacion autentico"

int main( void )
{
printf( "/%2s/\n", BLURB );
printf( "/%26s/\n", BLURB );
printf( "/123456789012345678901234567890/\n" );
printf( "/%26.5s/\n", BLURB );
printf( "/123456789012345678901234567890/\n" );
printf( "/%-26.5s/\n", BLURB );

return 0;
}

</syntaxhighlight>

=== Resultado ===

[rrc@Pridd CClase]$ gcc -Wall -O2 -o Prog18 Prog18.c
[rrc@Pridd CClase]$ ./Prog18
/Imitacion autentico/
/ Imitacion autentico/
/123456789012345678901234567890/
/ Imita/
/123456789012345678901234567890/
/Imita /
[rrc@Pridd CClase]$

=== Explicación ===

[[Category:Programación en C]]
[[Category:CCabal]]
[[Category:CursoC]]