Nota del Autor. Deseo que expresen sus dudas y opiniones para que este apéndice se verdaderamente enriquecedor para los lectores de la obra final, de momento es pequeño por que mis conocimientos en el area son reducidos.

Apéndice C: Notas breves sobre licencias libres

 Aunque hemos pretendido ser formales en los aspectos técnicos del lenguaje C, existen otros asuntos que es conveniente tratar cuando se crea software. Esto es las licencias.

 El software como cualquier otra obra de autoría propia, el autor tiene todos los derechos sobre el esto es lo que se llama copyright. Cuando decidimos liberar nuestra obra podemos hacerlo en diferentes formas, una –y la menos recomendable- es dejarla al dominio publico, es sin duda la forma mas sencilla porque solo hay que dejarla sin copyright. Esta forma de liberar la obra nos deja sin los recursos para poder demostrar la autoría de la obra y con ello sus derechos.

 La otra forma es por medio de una licencia “libre” u”OpenSource”, esto se hace basándonos en el copyright, aunque normalmente este recurso se usa para limitar la libertad del usuario del software, también se puede usar para lo contrario, de esta idea han nacido nazcan licencias especiales que dan privilegios de Uso, Copia, modificación, redistribución, tal vez bajo ciertas restricciones propias de cada licencia.

 En cuanto a las licencias su proliferación es increíble aunque las mas usadas son GPL,  BSD y MIT. Esto para software, pero ningún software es bueno si no tiene su documentación y esta también hay que licenciarla tenemos opciones como Creative Commons, GNU FDL y por supuesto Mononeurona Commons License bajo el cual se licencia el presente trabajo.

 La elección de la licencia es personal y deberá ser adecuada para la obra, usaremos un ejemplo sencillo para mostrar los pasos del licenciamiento en este caso con licencia 4-clause BSD (Original BSD)

 1.-Debemos agregar el copyright con año y nombre

//”Copyright © 2007 , Alberto Rodríguez Sánchez  (Vendaval) all rights reserved”
/*University of California, Berkeley*/

 Nota que use “copyright” y no derechos de copia o algo similar, no uses traducciones en especial cuando usas licencias en ingles. Cuando tú obra tenga varias versiones a través de los años incluirás TODOS esos años.

 2.-Debemos agregar la nota que establezca que se puede copiar bajo los términos de la licencia elegida. en este caso Original BSD, pero es lo mismo para GPL o MIT.

 3.-Se debe entregar una copia completa de la licencia junto con el código fuente, suele entregarse en un archivo con el extraño nombre “LICENSE”. En este caso les dejo un enlace a la licencia BSD.

Un pequeño ejemplo con este programa:

/* Copyright (c) 2007, Alberto Rodriguez Sanchez "vendaval"
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the COLECTIVO MONONEURONA nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY ALBERTO RODRIGUEZ SANCHEZ "VENDAVAL" ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL ALBERTO RODRIGUEZ SANCHEZ "VENDAVAL" BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include<stdio.h>

int main()
{
printf(“HOLA SANDRA”);

return 0;
}//Fin funcion principal

Nota Final.

Aunque muchos prefieren la licencia GPL v2, explico que de nuevo que tiene que ver con preferencias personales o las necesidades especiales del proyecto.

El objetivo de esta pequeña nota es introducir al tema de las licencias que es en realidad complejo y extenso, pero con este pequeño ejemplo podemos hacer valer nuestros derechos y nuestra filosofía.

Para Saber mas:
www.gnu.org/licenses
www.opensource.org

y google.

Comencemos con un ejemplo mas o menos sencillo:

#include<stdio.h>
#include<ctype.h>/*biblioteca que proporciona la funcion tolower*/

int main()/*inicio funcion principal*/
{
int A1[][3]={{1,2,3},{0,9,8},{5,6,4}};
int A2[][3]={{9,10,31415},{217,3000,2},{}};
int i,j,n,m;
char c;

printf("\n\nMenu\nMostrar arreglo A1 y A2->a\n");
printf("Crear y mostrar nuevo arreglo->b\n\n");
scanf("%c", &c);
c=tolower(c);/*cambiamos a minusculas*/

switch(c)
{
    case 'a':
        printf("A1:\n");
        for(i=0;i<3;i++)
        {
        for(j=0;j<3;j++)
            printf("%d ",A1[i][j]);
        printf("\n");
        }
       
        printf("\n\nA2:\n");
        for(i=0;i<3;i++)
        {
        for(j=0;j<3;j++)
            printf("%d2 1º",A2[i][j]);
        printf("\n");
        }
        break;
       
    case 'b':
        {
        printf("Introduce 2 numeros enteros");
        scanf("%d %d", &m, &n);
        int B[m][n];
        printf("Introduce %d elementos\n",m*n);
        for(i=0;i<m;i++)
            for(j=0;j<n;j++)
                scanf("%d",&B[i][j]);
        printf("El arreglo que introduciste es:\n");
       
        for(i=0;i<m;i++)
            {
            for(j=0;j<n;j++)
                printf("%d ",B[i][j]);
            printf("\n");
            }
        }
        break;
       
   
    default:
        printf("Entrada no valida\n");
        break;
}   

return 0;
}//fin funcion principal

Entre las cosas nuevas que encontraremos en este programa están los arreglos bidimencionales, tememos la declaración y asignación de valor de A1 y A2, para denotar cada fila se usa un par de llaves "{}", observa que A2 tienen el ultimo grupo de llaves vacío, el compilador les asignara el valor 0 a todos los componentes de esa fila, así cuando desees un arreglo con todos sus valores 0 puedes declarlo como Arreglo[tamaño]={0}; darle valor al primer elemento es necesario.

Los arreglos bidimencionales son muy utiles para representar tablas, grafos, matrices, etc. y son una facilidad de la programacion, al igual que los arreglos de una dimensión, son estructuras de datos que tienen un mismo tipo y que estan ordenados en posiciones contiguas de memoria,en la declaracion de A1 y A2 nota que solo declare el numero de filas (3), esto es porque C require sabes cuantas posiciones debe recorrer antes de aumentar una fila, pues todos los datos estan "alineados" en memoria.

Tenemos una estructura de control nueva switch(), Esta toma el valor de su argumento que puede ser un entero o un char y busca entre los casos (case) para ejecutar una acción, normalmente existe una expresión default que se realiza en caso de que la entrada no coincida con ningún caso. esta expresión default es opcional. tambien es de notarse que cada caso termina con "break", esto sale de switch y continua ejecutando la instruccion despues de la llave del cierre de switch. en el ultimo caso o caso default al final de switch no es necesario poner el break,pero es mejor ponerlo por claridad. la estructura basica es :

switch(Variable entera o char)
{
case var1:
                instruciones
                break
case var2:
                instruciones
                break::
case var3:
                instruciones
                break:
......
default:
                instruciones
                break:
}

Tambien tenemos el uso de la función tolower() de la biblioteca estandar ctype.h, esta funcion tomauncaracter y lo convierte a minuscula si es mayuscula, de lo contrario devuelve el mismo caracter. existe su contrario que va de minusculas a mayusculas, esta función se llama toupper() y se utiliza de la misma manera.

Existen muchas funciones en diversas bibliotecas que son parte del estandar ASCI,aun no se como presentare dichas funciones, de momento usare algunas y explicare su uso y biblioteca que contiene su "prototipo". En la literatura técnica primero se enseñan las funciones y luego los arreglos, supongo que con fines pedagogicos. veremos funciones en la siguiente entrada.

Hoy vimos:

1.-Declaración de arreglos Bidimencionales.
2.-Recorrido de arreglos bidimencionales.
3.-Instrucción switch..case..default
4.-Casos especiales de uso de switch.
5.-Función tolower y toupper.

Dudas en los comentarios.

Nota: El programa presentado esta escrito de una manera "poco practica", esto con fines de hacer versiones mejoradas de el.

Mi camino sobre GNU/Linux fue asi:

Debian GNU/Linux potato 2 semanas -> Mandrake 1 mes -> Ubuntu 1 semana -> Slackware 9, 10 creo? como un año o mas -> Debian GNU/Linux etch, lenny, sid a la fecha-> Estudio profundo de teoria de sistemas operativos->Otros Nucleos proximamente
En lo particular -como muchos- regalo Ubuntus, Me puse triste cuando Martin dejo de vender Ubuntus en el metro,me dio algo de pena poner la noticia de que Ubuntu podria dañar los discos duros de las laps, meda gusto ver a gente con su kubuntu, edubuntu, ubuntu estudio, etc. Ese era el fin ultimo de que se trabajara tanto haciendo las cosas fáciles, pero eso no quiere decir que conozcas -diria aarkerio- las tripas del sistema y el verdadero hacker las conoce, las modifica y las reescribe, por que las puede entender.

Un Ubuntu en un principio no es para desarrolladores, no tienen ni librerías de desarrollo ni compiladores, para hacerlo servidor tendrías que desinstalar mil y un madres, tu sabes "volarle" las X, agregarle ssh server, etc

El punto que defiendo es que de las distribuciones de linux hay un rey y una reyna -Slackware y Debian- que son de las que mas te permiten aprender mas de como funciona tu cacharro con el núcleo Linux. Es como en el ajedrez, el rey es el mas importante, donde aprenderás mas.

Pero la Reyna es la mas rompe madres de todas las otras piesas.

P.D: Creo que el caballo, mi pieza favorita, seria CentOS

veremos un nuevo ejemplo para introducirnos

#include<stdio.h>
#define NUM 10

int main()// Inicio del programa
{
int A[NUM], i; /*Vector,arreglo de enteros y un indice*/

printf("Introduce 10 numeros\n");

for(i=0;i<10;i++)
    scanf("%d", &A[i]);
 
printf("Tus numeros son:\n");
for(i=9;i>=0;i--)
    printf("%d ",A[i]);

printf("\n");

return 0;
}//fin del programa

En la primera linea del main() declaramos un Arreglo (int A[NUM]) la declaracion del arreglo se hace asignadole un nombre (A) y un tamaño (NUM), asi como un tipo (int). Un arreglo es una estructura de datos que asigna espacios consecutivos en memoria del tamaño del tipo declarado.

Para "movernos" dentro del arreglo ocupamos los subindices, cada subindice indica un valor dentro del arreglo, en C los subindices comienzan en 0, la asignacion de un valor se hace a cada elemento, nota que usamos un ciclo for para llenar el arreglo, aunque se puede usar otro ciclo o asignar individualmente una valor a cada elemento. tambiense pueden asignar los valores en la declaracion, veamos el siguiente ejemplo:

#include<stdio.h>
#define TAM 10

int main()//Inicio de la funcion principal
{
int Arreglo[]={1,2,3,4,5,6,7,8,9,0};//declaracion del arreglo
int i,j;

for(i=0;i<TAM;i++)//imprime un histograma de frecuencias
    {
    for(j=1;j<=Arreglo[i];j++)
        printf("*");
    printf("\n");
    }    

printf("Cambia los valores: ");

for(i=0;i<TAM;i++)
    scanf("%d",&Arreglo[i]); //Modificalos valores iniciales

for(i=0;i<TAM;i++)//imprime un nuevo histograma
    {
    for(j=1;j<=Arreglo[i];j++)
        printf("*");
    printf("\n");
    }

return 0;
}//Fin funcion principal

Nota que esta vez declaramos el arreglo con la lista de sus elementos,no declaramos el numero de elementos que tenia,pero si el tipo y el nombre. un arreglo se puede ver como un conjunto de variables del mismo tipo,eso nos evita declarar muchas variables individuales y ademas facilita la programacion gracias a los subindices.

El tipo del arreglo puede ser cualquiera, ademas un arreglo tiene una fuerte conexion con los apuntadores, que es una de las caracteristicas mas poderosas del lenguaje. dada esta conexion nota que si asignas un valor a Arreglo, es lo mismo que si asignaras un valor a Arreglo[0].

Es importante saber que los subindices son siempre valores enteros, no tiene sentido una posicion no entera,bueno dada esta propiedad de los subindices juguemos y vamos unas posibilidades en el siguiente ejemplo:

#include<stdio.h>

int main()/*Inicio funcion principal*/
{
int i,j,tam;
float temp;

printf("Introduce el tamanio del arreglo: ");
scanf("%d", &tam);

float A[tam];//declaracion del arreglo

printf("Introduce los valores flotantes");
for(i=0;i<tam;i++)
    scanf("%f", &A[i]);

for(i=1;i<tam;i++)//Ordenamiento metodo de la burbuja
    for(j=0;j<tam-1;j++)
        if(A[j]>A[j+1])
            {
            temp=A[j];
            A[j]=A[j+1];
            A[j+1]=temp;
            }
           
printf("Arreglo ordenado\n");
for(i=0;i<tam;i++)
    printf("%f ", A[i]);

printf("\n");

return 0;
}//Fin Funcion principal

Nota como podemos hacer operaciones en los subindices, esto siempre y cuando regresen valores enteros

Solo una nota breve sobre el ordenamiento, El ordenamiento es una de las aplicaciones computacionales mas  importantes, el metodo de ordenamiento de la burbuja (Bubble Sort) es muy facil de programar y entender, sin embargo, es la PEOR forma de ordenar un conjunto de datos, existen alrededor de unos 300 metodos de ordenamiento, yo sinceramente conozco como quince, sea cual sea el caso, Nunca ordenen por este metodo cuando la cantidad de datos sea grande, para aprender esta bien ;).

Hoy vimos

1.-Declaracion de arreglos
2.-Manejo de subindices
3:-Asignaciones de valor a elementos del arreglo.

Les dejo un pequeño problema: Imagina un ordenamiento en zic zac, es el metodo de la burbuja, pero pasa hacia delante y luego hacia atras, esto quiere decir que en una pasada  (ida y vuelta) el valor mas grande y mas pequeño quedan acomodados y asi sucesivamente, notaras que no requiere todas las iteraciones del metodo de la burbuja tradicional.

Programalo y optimizalo. Si puedes ponlo en los comentarios,recuerda "Muestra tu Codigo".

Una nota breve acompañada de una pequeña historia.

Un día un reportero se le acerco a Bruce Lee y le dijo que había alguien que lo retaría y que podia lanzar miles de patadas distintas, Bruce Contesto "No tengo miedo del hombre que pueda lanzar 10,000 patadas distintas, temo al hombre que a lanzado una patada 10,000 veces". Disculpen que los problemas parezcan sencillos y repetitivos, pero yo en lo particular pienso ( y es la filosofia de este curso) que el maestro domina lo basico y ese diminio lo lleva a comprender las cosas superiores.

Retomando el curso veamos un nuevo ejemplo de código:

/*Programa que hace una cuenta hacia delante y hacia atrás del numero dado*/
#include<stdio.h>

int main() /*Inicio del programa*/
{
int n, i=0, j; /*Declaro variables*/

printf("Hasta que numero quieres contar??? : ");
scanf("%d", &n); /*Leo y asigno un valor entero a la variable*/

while(i<=n) /*Ciclo While mientras 'i' sea menor o igual que 'n'*/
{
printf("%d ",i);
++i; //Operador de incremento (++) suma uno a la variable es igual a i=i+1; pero mas elegante
}

for(j=n;j>=0;j--) /*Ciclo for, cuenta regresiva usando el operador decremento (--)*/
printf("%d ",j);

return 0;
}//Fin de main()

Pues tenemos un nuevo elemento se trata del ciclo while, este realizara las instrucciones que estén dentro de su cuerpo mientras su condición sea verdadera (distinta de cero 0), la condición se encuentra entre los paréntesis y debe modificarse (comúnmente) dentro del cuerpo del ciclo, Dese este momento debemos cuidar que nuestros programas no se ciclen hasta el infinito ("y mas alla" ;) ) , es importante saber que la expresion se evalua antes de iniciar el ciclo, entonces si la condición es falsa no se realizara ninguna acción del cuerpo del ciclo. Su sintaxis es así

while(expresion)
instrucciones

ó

while(expresion)
{
Instruccion
instruccion
...
instruccion
}

La expresión suele ser una comparación pero puede ser una variable o -incluso- una constante. el ciclo for es una version simplificada de while, pues incluye todos los elementos de control del ciclo en una sola parte.

for( Expresion1;Expresion2; Expresion3)
{
....
}

Es igual a:

Expresion1;
while(Expresion2)
{
....
Expresion3;
}

Expresion1 suele ser la inicializacion de una variable, la Expresion2 podria ser una comparacion y la tercera una modificación en una variable, pero todo esto es optativo para el ciclo for, pues la sintaxis puede ser asi for( ; ; ) lo que nos llevaría a un ciclo infinito

Decidir entre una u otra expresión suele ser cuestión de gustos o legibilidad. Aunque en situaciones mas complejas como cuando se usa continue del que hablare mas adelante.

Tambien tenemos los operadores de incremento(++) y decremento(--), estos operadores son muy utiles pues facilitan muchas operaciones. Existen algunos detalles que es importante destacar, estos operadores dependiendo de que lado del operando se ponga se evalúan en un tiempo distinto, si ponen antes (++i) se incrementan primero y luego se evalúan, si lo pones del lado derecho (i++) primero se evaluan y luego se incrementa, es lo mismo para el operador decremento. Estas anotaciones tienen que ser tomadas en cuenta cuando los operadores estan dentro de una expresión mas compleja.

Veamos un nuevo ejemplo

/*Otro Contador*/
#include<stdio.h>

int main() // Inicio programa principal
{
int i;
for(i=0;i<=10;i++)
{
if(2==i)
continue; //indica que continue en la sig. iterasion del ciclo
if(9==i)
break; // Indica que salga del ciclo
printf("%d ",i); //Imprime el valor de i
}

return 0;
} /* Fin programa principal*/

Compila y prueba.

Continue indica que pase a la siguiente Iteracion del ciclo,sin terminar las instrucciones de la iteracion presente, esta sentencia NUNCA debe usarse en el ciclo while esto por que se desconocera cual es la siguiente iteracion debido a que las variables de control estan en el cuerpo del ciclo.

Break dice que se saldra del ciclo donde se encuentre, esto permite terminar ciclos antes de que se cumpla la condicion de paro.

Un ultimo ejemplo por hoy.

/*Programa "hoy es navidad???"*/
#include<stdio.h>

int main() /*Inicio del programa */
{
char c;
do
{
printf("HOY ES NAVIDAD??? (y/n)");
scanf("%c", &c);
if(c=='y')
printf("FELIZ NAVIDAD\n");
}While(c=='n');

return 0;
}/*Fin */

DO...WHILE() -hacer...mientras- Es una variante del ciclo while que ejecuta al menos una vez la accion, esto por que primero realiza las instruciones dentro del cuerpo y luego evalua la expresion si la expresiones verdadera repite el ciclo.Su sintaxis es asi:

do
{
Instruccion
Instruccion
....
Instruccion
}while(Expresion);

Nota el punto y coma despues de while.


Hoy aprendimos:

1.-Ciclo while.
2.-Ciclo for
3.-Operadores de incremento y decremento (++ y --)
4.-Continue y break;
5.-Do..while

Despues de la siguiente entrada vendra una ronda de ejercicios, algunos que no los dejaran dormir.

Continuamos con la explicación sobre los tipos de datos.

Bueno diremos que existen tipos de datos primitivos y otros creados por el usuario.
los datos primitivos son los siguientes (ya había mencionado a varios de ellos)

Tipo	Descripcion
char	Caracteres
int	Entero
float	Numero de punto flotante con precisión simple
double	Numero de punto flotante con precisión doble
void	Tipo Nulo
apuntador	Direccion de memoria

Los tipos de datos están sujetos aun tamaño, esto quiere decir que hay un valor máximo que se puede representar con una variable de ese tipo. El tamaño de dato depende fuertemente de la maquina,por ejemplo el tamaño de un int (entero) puede estar en 16 bits o 32 bits, El tipo char en C estándar mide siempre 8 bits este numero basta para poder representar cualquier carácter ascii,  El float esta en 32bits y el double en 64bits. pero como exprese antes depende de tu maquina, pero pues podemos hacer algo para saberlo, C ofrece la función "sizeof()" que obtiene el tamaño de su argumento. veamos como se usa con un ejemplo sencillo:

#include<stdio.h>

int main()
{
printf("%d %d %d %d\n",sizeof(char), sizeof(int), sizeof(float), sizeof(double));
return 0;
}

El Resultado lo entrega en bytes (8 bits), digamos que tu necesitas valores mas chicos o grandes, pues puedes usar modificadores como "short" y "long", habrá otras veces que solo quieras trabajar con números positivos, entonces defines la variable como "unsigned", que tiene una contra parte "signed" que es el dafault.

/*Ejercicio: Modifica el programa anterior para que muestre los tamaños de long int y shot int, lo mismo para los demás tipos ,escribe los así sizeof(long int),etc*/

Tal vez alguien dijo y ese tipo nulo "void", seguro que alguna vez querrás hacer algo que ejecute una acción pero que no te devuelva nada, para eso es el tipo void, si no me entendiste cuando veamos funciones te quedara muy claro

Los datos definidos por el usuario los veremos mas adelante, de momento no los necesitaremos, pero su existencia le dan gran potencia C.

Usemos un ejemplo para entrar en otros temas.

#include<stdio.h>
#define PI 3.1416 /*Constante simbolica*/

int main()
{
float entrada, salida;
char c;

printf("Introduce que deseas calcular del circulo:\n");
printf("Area presiona 'a'\nPerimetro presiona 'p'\n");
scanf("%c", &c);

if(c=='a') /*sentesia if y expresion  de comparación*/
    {
    printf("Introduce el radio:");
    scanf("%f"",&entrada);
    salida=PI*(entrada*entrada);
    }
else if(c=='p') /*else y segunda comparacion*/
    {
    printf("Introduce el diametro:");
    scanf("%f", &entrada);
    salida=entrada*PI;
    }
else /*caso default*/
    printf("Entrada Erronea\n");

printf("El resultado es:%f\n", salida);
return 0;
} //fin de la funcion principal

La primera novedad en la segunda linea encontramos una "constante simbolica" que llamamos varias veces en el cuerpo del programa,no se le puede asignar ningun valor dentro del programa por que generaria un error, en realidad, el #define le dice al preprocesador de C,que en cualquier lugar que encuentre la coincidencia PI la substituya por 3.1416, esto es de gran utilidad, imagina que de repente solo quieren que hagas el calculo con 3.14 o 3.1415...,entonces solo basta modificar el valor de la constante y listo. gracias a esta opcion podemos substituir muchas cosas como valores de constantes fisicas o formulas, Nota que se escribe como un encabezado pero que en vez de #include ocupa un #define.

Encontramos las sentencia if, esta sentencia es muy importante, pues permite que nuestros programas "Tomen decisiones" por medio de la condicion que reciben como argumento, veamos el primer if:  if(c=='a') dentro de su argumento tenemos una comparacion (o podemos encontrar otro tipo de operacion) ,  las comparaciones siempre devuelven un valor entero que se interpreta como falso o verdadero,falso es cero (0), verdadero es cualquier otro numero.

Las acciones a ejecurar si la condicion se cumple pueden ser una o muchas, si son muchas usaremos llaves para encerrarlas, mira:

if(algo)
    haz esto
if(otra cosa)
    {
    haz esto
    y esto
    ...
    esto otro y ya
    }

Un if puede estar acompañado de la sentencia else trabajando juntos mas o menos asi:

SI (if)
    haces algo
SI NO (else)
    haces otra cosa

Las mismas reglas para cuantas instrucciones ejecuta el if se aplican al else, es importante que si quieres que se ejecuten varias instrucciones en el "cuerpo" del else usas las llaves {}, de no hacerlo, tu programa no  hara lo quieres.

Dentro del codigo podemos ver algo como "else if" que es algo como SI NO y SI haz esto. aunque solo hemos acupado comparaciones de igualdad, podriamos checar si el valor es menor o mayor que otro. vamos a  reescribir el programa anterior pero usando  tambien operadores logicos:

#include<stdio.h>
#define PI 3.14159265

int main() /*Inicio programa principal*/
{
float  In,Out;
char c;

printf("Que deseas calcular area (a) o perimetro  (p)\n"); //Despliego letrero
scanf("%c", &c); //leo y asigno una variable tipo char

if( (c=='p') || (c=='a'))  /*Si es 'p' O 'a'*/
    {
    printf("Introduce el radio:");
    scanf("%f",&In);/*Lee y asigna una un valor flotante la variable In*/
    if('p'==c) //Si es perimetro hace
        Out=2*PI*In;  
    else //Si no (entonces es area)hace lo siguiente
       Out=PI*In*In;
    }
else
    printf("Entrada no valida");

printf("Resultado= %f\n", Out); /*Imprime el resultado*/
return 0;
} /*Fin programa principal*/

El programa debe entregar (casi)la misma salida que el enterior, la primera diferencia es que esta vez definimos PI con un valor un mas cercano a la realidad, despues y importante esta el primer if.

if((c=='p') || (c==a))

Los "||" denotan la operacion logica OR que dice que si al menos uno de las dos comparaciones es verdadera realice la instruccion. hay otros dos operadores logicos && y ! (AND y NOT),  El && realiza la operacion si y solo si los dos operandos son verdaderos,si no, pues no. el ! solo opera sobre un operando y lo niega (si es verdadero lo vuelve falso, si es falso lo vuelve verdadero). ejemplos del uso de estos operadores los veremos despues y los usaran en los proximos ejercicios.

Hoy vimos:

1.-El tamaño de los tipos de datos.
2.-Constantes simbolicas
3.-Instruciones If y else
4.-Comparaciones
5.-Opereadores logicos

Dudas, aclaraciones y correcciones en los comentarios

Primero una disculpa,parece ser que en ningún momento dije cuales serian los objetivos y los temas del curso, sobre los temas yo mismo no lo se, terminare con algo como estructuras, pasando por dos o mas entradas sobre apuntadores, si sera algo largo y prefiero escribirlo en intervalos reducidos para no perder la continuidad (ni el interés). Le estoy tratando de dar un enfoque practico, aprendiendo por medio de ejemplos, mi base para hacerlo son mis propios conocimientos y un par de libros, que me ayudan a aprender, entonces no siempre daré toda la referencia técnica,  sobre el tema, pues el objetivo es que adquieran las habilidades y el conocimiento necesarios para que puedan hacer programas con dos intereses: Optimos (mas al final del curso) y Aplicaciones gráficas (no se aun si con gtk o qt, voten) estas las aprenderé con ustedes, pues solo he usado gtk en C#, pero bueno, al final tendremos alguna aplicación con interfaz gráfica y con desempeño optimo (o casi).

Una cosa mas sobre la optimizaron, estoy consiente de que este es el objetivo mas difícil y hay que tener corazón espartano para lograrlo, todos podemos hacer programas que resuelvan un problema, pero que ese problema sea resuelto de la mejor forma posible es objetivo de investigadores y cursos muy avanzados de algoritmia, aquí solo sentare las bases para un asunto muy (muy) especifico, pero al final tendremos la satisfacción de haber hecho las cosas realmente bien.

El libro que mas consulto es el "El Lenguaje de programación C" de Ritchie y Kernighan

Sin duda,mi mayor compromiso es ofrecerles calidad, tal vez tenga que agregar cosas en entradas anteriores, pero siempre  les avisare de ello.

Saludos
.

Dicen Kernighan y Ritchie que "La unica manera de aprender un lenguaje es haciendo programas en el."

Y yo aprendí (aprendo todavía) haciendo muchos programas y ustedes tambien (estoy planeado llegar en este cursito al menos a 150)

1.-Haz un programa que imprima  una frase (como "Hola Nena como estas hoy" o "Debian Rulez")  una palabra por linea.

2.-Haz un programa que imprima la misma frase pero las palabras separadas por tabulaciones y emita una alerta al final.

3.-Haz un programa que lea tu edad desde el teclado y luego te lo escriba en pantalla.

4.-Haz un programa que lea 3 números enteros, sume los dos primeros y al resultado le reste el tercero, muestra el total en la pantalla.

5.-Haz un programa que lea tres enteros,los muestre por separado y después su suma.

6.-Haz un programa que lea el radio de un circulo y te diga su perímetro y su área.

7.-Haz un programa al cual le introduzcas los lados de un rectángulo y te regrese su perímetro y su area.

8.-Haz un programa que imprima una arbolito de Navidad con '*' así : (tal vez un poco mas grande y mejor hecho)
      *
    ***
  *****
     *
9.- Al árbol del ejercicio anterior ponle esferas y música.(coff*coff* o,0 y \a) /*manejo de printf*/

10.- Haz un programa que te convierta una entrada a de grados Celsius a Fahrenhait

11.-Haz un programa que cuando se le introduzca un numero de 4 digitos,lo separe por cada digito (si entra 1234, regresa  1 2 3 4) /* Usa modulo y divisiones */

Todos los programas se pueden resolver con lo que hemos visto hasta ahora. Si tienes alguna duda, puedes mandar tu código para que lo veamos y mejoremos juntos.

Nota mia: Me acabo de dar cuenta que omití algunos asuntos técnicos de importancia, como la longitud (tamaño) de los datos, esto lo explicare en la siguiente entrada. saludos

#include<stdio.h>

int main() //inicio función principal
{
int besos; //declaración de la variable tipo entero "besos"

printf("Cuantos Besos quieres darle a la nena??"); /*Despliega letrero*/
scanf("%d",  &besos); /*Recibe datos de la entrada estándar, los transforma y guarda en la variable besos*/

printf("Hola Nena quiero darte %d besos", besos); /*saluda a la nena y le dice cuantas veces quieres besarla*/

return 0; /*terminación exitosa del programa */
} //fin función principal

ahora compila...


Toda variable corresponde a un tipo de datos, veamos algunos tipos de datos

Tipo de dato	descripción	especificador de conversión
int	Números enteros	%d
float	Números de punto flotante	%f
double	Números de punto flotante de doble precisión	%f
char	carácter ascii	%c