Tutoriales de c

« 1/2 2 »

Este programa te ilustra para manipular los arreglos de caracteres en c.

#include <stdio.h>

/* la función main comienza la ejecución del programa */
int main()
{
   char cadena1[ 20 ]; /* reserva 20 caracteres */
   char cadena2[] = "literal de cadena"; /* reserva 18 caracteres */
   int i; /* contador */

   /* lee la cadena del usuario y la introduce en el arreglo cadena1 */
   printf("Introduce una cadena: ");
   scanf( "%s", cadena1 ); /* entrada que finaliza con un espacio en blanco */

   /* muestra las cadenas */
   printf( "La cadena1 es: %s\ncadena2 es: %s\n"
           "La cadena1 con espacios entre caracteres es:\n",
           cadena1, cadena2 );

   /* muestra los caracteres hasta que encuentra el caracter nulo */
   for ( i = 0; cadena1[ i ] != '\0'; i++ ) {
      printf( "%c ", cadena1[ i ] );
   } /* fin de for */

   printf( "\n" );

   return 0; /* indica terminación exitosa */

} /* fin de main */

 

Autor: hugo

Ay que tener en claro que las aplicaciones realizadas con la API de win32 solo funcionan en plataformas Windows.

Si el ejemplo no funciona es por el compilador de C++ la siguiente aplicación esta echa en Dev-C++, no entonos los compiladores funciona ya que cada una esta modificado por el fabricante, para que tengas cuidado. Aunque la idea es la misma.

Al final puedes descargar muchos ejemplos creados incluyendo este para que los puedas analizar.

Para comenzar crearemos la función principal en donde se hace la ventana en la cual trabajaremos.

Primero tenemos que registrar en el sistema una clase ventana, estilos, cursor, iconos, etc.
Después creamos la ventana con CreateWindowEx, le pasamos parámetros de posición, tamaño, titulo clase ventana, etc.
Por ultimo lo mas importante el bucle de mensajes, es por donde pasan todos los mensajes producidos en la ventana, este los obtiene y los manda el WndProc donde son procesados para realizar alguna acción.



int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
	LPSTR lpCmdLine, int nCmdShow)
{
	WNDCLASSEX wc; //clase estructura de la ventana
	HWND hwnd;     //var de la ventana
	MSG Msg;

	wc.cbSize		 = sizeof(WNDCLASSEX);
	wc.style		 = 0;
	wc.lpfnWndProc	 = WndProc;
	wc.cbClsExtra	 = 0;
	wc.cbWndExtra	 = 0;
	wc.hInstance	 = hInstance;
	wc.hIcon		 = LoadIcon(NULL, IDI_APPLICATION);
	wc.hCursor		 = LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
	wc.lpszMenuName  = NULL;
	wc.lpszClassName = g_szClassName;
	wc.hIconSm		 = LoadIcon(NULL, IDI_APPLICATION);

	if(!RegisterClassEx(&wc))
	{
		MessageBox(NULL, "El registro de windows fallo!", "Error!",
			MB_ICONEXCLAMATION | MB_OK);
		return 0;
	}

	hwnd = CreateWindowEx(
		WS_EX_CLIENTEDGE,
		g_szClassName,
		"Tablas de multiplicar",
        WS_SYSMENU ,
		CW_USEDEFAULT, CW_USEDEFAULT, 500, 500,
		NULL, NULL, hInstance, NULL);

	if(hwnd == NULL)
	{
		MessageBox(NULL, "No se creo el windows!", "Error!",
			MB_ICONEXCLAMATION | MB_OK);
		return 0;
	}

	ShowWindow(hwnd, nCmdShow);
	updateWindow(hwnd);


	while(GetMessage(&Msg, NULL, 0, 0) > 0)
	{
		TranslateMessage(&Msg);
		DispatchMessage(&Msg);
	}
	return Msg.wParam;
}


En nuestro WndProc le decimos que es lo que queremos que haga nuestra ventana, primero le decimos que haga los controles de nuestra ventana, después en WM_COMMAND le estamos diciendo que las acciones entren y se comparan para hacer la multiplicación de las tablas y las asigna al listbox.



LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{

static HWND mosButton=0,borButton=0,salButton=0,tEdit=0,mListbox,tStatic=0;

	switch(msg)
	{
        case WM_CREATE:
        {

             mosButton = CreateWindow (
             "button",/*class del boton*/
             "Mostrar",
             WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, /*style del boton*/
             300, 100, (10*8), (10*2),
             hwnd,/*id del windows*/
             (HMENU) 1,/*id del control*/
             ((LPCREATESTRUCT) lParam)->hInstance,
             NULL
             );

             mosButton = CreateWindow (
             "button",
             "Borrar",
             WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
             300, 150, (10*8), (10*2),
             hwnd,
             (HMENU) 2,
             ((LPCREATESTRUCT) lParam)->hInstance,
             NULL
             );

             mosButton = CreateWindow (
             "button",
             "Salir",
             WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
             0, 0, (10*8), (10*2),
             hwnd,
             (HMENU) 3,
             ((LPCREATESTRUCT) lParam)->hInstance,
             NULL
             );

             tStatic = CreateWindow (
             "static",/*class del boton*/
             "No de la tabla:",
             WS_CHILD | WS_VISIBLE, /*style de la etiqueta*/
             50, 80, (10*10), (10*2),
             hwnd,/*id del windows*/
             (HMENU) 6,/*id del control*/
             ((LPCREATESTRUCT) lParam)->hInstance,
             NULL
             );

             tEdit = CreateWindow (
             "edit",/*class del boton*/
             "1",
             WS_CHILD | WS_BORDER | WS_VISIBLE, /*style de la caja de txt*/
             150, 80, (10*5), (10*2),
             hwnd,/*id del windows*/
             (HMENU) 4,/*id del control*/
             ((LPCREATESTRUCT) lParam)->hInstance,
             NULL
             );

             mListbox = CreateWindow (
             "listbox",/*class del boton*/
             "",
             WS_CHILD | WS_VSCROLL | WS_BORDER | WS_VISIBLE, /*style de la lista*/
             50, 100, (10*25), (10*20),
             hwnd,/*id del windows*/
             (HMENU) 5,/*id del control*/
             ((LPCREATESTRUCT) lParam)->hInstance,
             NULL
             );

        return 0;
        break;
        }
        case WM_COMMAND:
             switch(LOWORD(wParam))
			 {
                 case 1:  //Mostrar
                 {
                      BOOL bSuccess;
                      int nTimes = GetDlgItemInt(hwnd, 4, &bSuccess, false);
                      if(bSuccess)
                      {
                          int i;
                          char text[35],nu[3];
                          char* buf;

                          for(i = 0;i < 10; i++)
                          {
                              gcvt(nTimes,5,nu);
                              strcpy(text,nu);
                              strncat(text," X ",3);
                              gcvt(i+1,5,nu);
                              strncat(text,nu,strlen(nu)-1);
                              strncat(text," = ",3);
                              gcvt((i+1)*nTimes,5,nu);
                              strncat(text,nu,strlen(nu)-1);

                              int index = SendDlgItemMessage(hwnd, 5, LB_ADDSTRING,
                              0, (LPARAM)text);

                              SendDlgItemMessage(hwnd, 5, LB_SETITEMDATA,
                              (WPARAM)index, (LPARAM)i);
                          }
                          GlobalFree((HANDLE)text);
                      }
                      else
                      {
                          MessageBox(hwnd, "Escribe el No de tabla:", 
                      "Warning", MB_OK);
                      }
                 }
                 break;
                 case 2:  //borrar
                 {
                      SendDlgItemMessage(hwnd, 5, LB_RESETCONTENT, 0, 0);
                 }
                 break;
                 case 3:  //salir
                 {
                      SendMessage(hwnd,WM_CLOSE,0,0);
                 }
                 break;
             }
        return 0;
        break;

        case WM_LBUTTONDOWN:
		{
			char szFileName[MAX_PATH];
			HINSTANCE hInstance = GetModuleHandle(NULL);

			GetModuleFileName(hInstance, szFileName, MAX_PATH);
			MessageBox(hwnd, szFileName, "Este programa es:
                       ", MB_OK | MB_ICONINFORMATION);
		}
		break;
		case WM_CLOSE:
			DestroyWindow(hwnd);
		break;
		case WM_DESTROY:
			PostQuitMessage(0);
		break;
		default:
			return DefWindowProc(hwnd, msg, wParam, lParam);
	}
	return 0;
}


Autor: ElGame
Aqui envio un ejmplo claro del manejo de sockets en C++. Esta echo en el programa Dev-C++ el codigo del programa viene abajo y esta comentado chequenlo y si tienen una duda pregunten a hugo_chess1 carloshugogonzalezcastell@hotmail.com o al administrador de aqui osea gama
Autor: Hugo Gonzalez

Es muy simple crear una librería dll en visual C++, solo tienes que seguir estos pasos y buala se creara tu librería lista para usar en Visual Basic, Asp, etc.

Vamos a crear 5 funciones simples; suma, resta, ForGeneral, Par y DolaPeso.

Suma: esta función te devuelve el resultado de la suma de dos números, los parámetros que recibe son dos números enteros.
Resta: es igual que la función de arriba solo que te devuelve la resta de dos numaros.
ForGeneral: recibe los tres parámetros a, b y c que se necesitan para resolver la formula general, si se puede resolver entonces te regresa un 1 sino se puede resolver es 0.
Par: regresa 1 si el numero que enviaste es par de lo contrario regresa 0.
DolaPeso: recibe un valor entero que son los dólares, y te regresa la equivalencia en pesos.

Ahora comenzaremos a crear la librería:

1.- En Visual C++, creamos un Nuevo Project Workspace. En el cuadro de diálogo seleccionamos Type: MFC App Wizard (dll) y en el campo Name: ponemos Demo. Al hacer click en el botón Create... el asistente nos mostrará un nuevo cuadro de diálogo donde debemos seleccionar la opción Regular DLL with MFC statically linked y pulsar el botón Finish para terminar. Luego de unos instantes encontraremos que han sido creados varios archivos.

2.- Ubicamos el archivo principal del proyecto, llamado Demo.cpp y luego de las instrucciones dirigidas al preprocesador (que comienzan con #) incorporamos el código que corresponde a cada procedimiento:



extern "C"
int WINAPI Suma(int dato1, int dato2) /*Suma dos numeros*/
{
   int temp;
   temp=dato1+dato2;
   return (temp);
};
int WINAPI Resta(int dato1, int dato2) /*resta el dato1 - dato2*/
{	
   int temp;
   temp=dato1-dato2;
   return (temp);
};
int WINAPI ForGeneral(int a, int b, int c) 
{	/*Si se puede resulver una formula general 1 sino 0*/
    int im,di,re;
	im=(b*b) - (4*c*a);
	di=2*a;
	if(di!=0){
		if(im>=0){
			re=1;
		}
		else{
			re=0;
		}
	}
	else
		re=0;
	return(re);
};
int WINAPI Par(int dato) /*1 si es par 0 impar*/
{
   int re;
   if(dato % 2 == 0)
		re=1;
   else
		re=0;
   return (re);
};
int WINAPI DolaPeso(int dolar)
{		/*Convierte dolares a pesos*/
   int peso;
   peso=dolar*11;
   return (peso);
};


3.- El siguiente paso es agregar cada uno de estos procedimientos a la sección export del archivo Demo.def, para que puedan ser accedidas desde programas externos. Simplemente, para cada función en la DLL, añadimos una línea conteniendo el nombre exacto de la misma. En nuestro caso el archivo quedaría como sigue:



LIBRARY      "demo"
DEscriptION  'demo Windows Dynamic Link Library'

EXPORTS
   Suma
   Resta
   ForGeneral
   Par
   DolaPeso


4.- Después necesitamos proveer los prototipos de las funciones en el archivo de cabecera Demo.h. Los prototipos son exactamente iguales a las definiciones que agregamos a Demo.cpp pero sin los nombres de variables. El código que sigue lo agregamos al final del archivo Demo.h creado por el asistente:



#ifdef __cplusplus
extern "C" {
#endif
 
int WINAPI Suma(int, int);

int WINAPI Resta(int, int);

int WINAPI ForGeneral(int, int, int);

int WINAPI Par(int);

int WINAPI DolaPeso(int);
 
#ifdef __cplusplus
}
#endif


5.- Por último, salvamos todos los archivos y nos dirigimos al menú Build y seleccionamos Build Demo.dll para compilar un archivo de prueba que se creará en un subdirectorio \debug dentro del directorio principal del proyecto.

6.- Solo falta crear un proyecto en Visual Basic y le agregamos un modulo, le insertamos el script:



Public Declare function suma Lib "C:\demo\VB\demo.dll" _
   Alias "Suma" (ByVal Numero1 As Integer, ByVal Numero2 As Integer) As Integer
   Public Declare function resta Lib "C:\demo\VB\demo.dll" _
   Alias "Resta" (ByVal Numero1 As Integer, ByVal Numero2 As Integer) As Integer
   Public Declare function forgeneral Lib "C:\demo\VB\demo.dll" _
   Alias "ForGeneral" (ByVal A As Integer, ByVal B As Integer, ByVal C As Integer) 
As Integer  
   Public Declare function par Lib "C:\demo\VB\demo.dll" _
   Alias "Par" (ByVal Numero As Integer) As Integer
   Public Declare function dolapeso Lib "C:\demo\VB\demo.dll" 
   Alias "DolaPeso" (ByVal Dolares As Integer) As Integer


7.- y el ultimo paso es crear un formulario en el proyecto de Visual Basic y agregamos el codigo, para hacer la prueba.



Private sub Command1_Click()
    n1 = Text1.Text
    n2 = Text2.Text
    Label1.Caption = suma(n1, n2)
    end sub
    Private sub Command2_Click()
    n1 = Text3.Text
    n2 = Text4.Text
    Label2.Caption = resta(n1, n2)
    end sub
    Private sub Command3_Click()
    A = Text5.Text
    B = Text6.Text
    C = Text7.Text
    
    if forgeneral(A, B, C) = 1 Then
        MsgBox ("Si tiene solucion ")
    else
        MsgBox ("La raiz es imaginaria o div entre 0")
    end If
    end sub
Private sub Command4_Click()
    Numero = Text8.Text
    if par(Numero) = 1 Then
        MsgBox ("Es par")
    else
        MsgBox ("No es par")
    end If
end sub
Private sub Command5_Click()
    Dolares = Text9.Text
    Label4.Caption = "$" & dolapeso(Dolares)
end sub


Autor: ElGame
Introducción

Este método también es directo, es parecido al buble sort.

En este tipo de algoritmo los elementos que van a ser ordenados son considerados uno a la vez. Cada elemento es INSERTADO en la posición apropiada con respecto al resto de los elementos ya ordenados.

El método toma cada elemento del arreglo y lo compara con los que se encuentran en posiciones anteriores a la de él. Si el elemento comparado es mayor que el elemento a ordenar, se recorre hacia la siguiente posición superior. Si es menor, entonces el elemento ya esta ordenado.

Veamos un ejemplo utilizando este método para ordenar un vector. Puedes descargar el ejemplo funcionando al final.



#include<stdio.h>
#include<conio.h>

void main(void){
int au,i,n,a,vec[100],te;
clrscr();
	printf("Numeros a ordenar: ");
	scanf("%d",&n);
	for(i=0;i<n;i++){
	  printf("No %d ",i+1);
	  scanf("%d",&vec[i])	;
	}
	clrscr();
	for(i=0;i<n;i++)
	  printf("%d ",vec[i]);
	  printf("

");
	for(i=1;i<n;i++){  //algoritmo de insertion
	  te=vec[i];
	  a=i-1;
	  while(vec[a]>te && a>=0){
	    vec[a+1]=vec[a];
	    a--;
	    vec[a+1]=te;
	  }
	}
	for(i=0;i<n;i++)
	  printf("%d ",vec[i]);
getch();
}


Autor: Gamaliel M.
Introducción

Existen dos tipos de ordenación los directos y los logarítmicos. Cuando N (numero de elementos) es pequeño deben utilizarse métodos directos y cuando N es medio o grande deben emplear métodos logarítmicos.

El método de intercambio directo, conocido con el nombre de la burbuja, es el mas utilizado ente los estudiantes principiantes de computación, por su fácil comprensión y programación. Pero hay que señalar que es probablemente el método más ineficiente.

La idea básica de este algoritmo consiste en comparar pares de elementos adyacentes e intercambiarlos entre si hasta que todos se encuentren ordenados. Se realizan (n-1) pasadas, transportando en cada una de las mismas el numero a mayor elemento (según sea el caso) su posición ideal.

Aquí esta programa que ordena un vector de N elementos utilizando el buble sort. Al final puedes descargar un ejemplo funcionando.



#include<stdio.h>
#include<conio.h>

void main(void){
int au,i,n,a,vec[100];
clrscr();
      printf("Numeros a ordenar: ");
      scanf("%d",&n);
      for(i=1;i<=n;i++){
        printf("No %d ",i);
        scanf("%d",&vec[i]);
      }
      clrscr();
      for(i=1;i<=n;i++)
        printf("%d ",vec[i]);
        printf("

");
      for(i=2;i<=n;i++)  //algoritmo del buble sort
        for(a=n;a>=i;a--)
          if(vec[a-1] > vec[a]){
            au=vec[a];
            vec[a]=vec[a-1];
            vec[a-1]=au;
          }
      for(i=1;i<=n;i++)  //muetro vector ordenado
        printf("%d ",vec[i]);
getch();
}


Autor: Gamaliel M.
Introducción

Antes de abrir un fichero necesitamos declarar un puntero de tipo file, con el que trabajaremos durante todo el proceso. Para abrir el fichero utilizamos la función fopen().



Puntero=fopen(?datos.txt?,?r?);
Puntero=fopen(?c:\\txt\\datos.txt?,?w?);


Un archivo puede ser abierto de dos formas distintas, en modo texto o en modo binario.

Modo texto

w ---- crea un fichero de escritura. Si ya existe lo crea de nuevo.
w+ --- crea un fichero de escritura y lectura. Si ya existe lo crea de nuevo.
a ---- abre o crea un fichero para escribir al final del mismo.
a+ --- abre o crea un fichero para leer y añadir datos al final del mismo.
r ---- abre un fichero de lectura.
r+ --- abre un fichero de lectura y escritura.

Modo binario

wb ---- crea un fichero de escritura. Si ya existe lo crea de nuevo.
w+b --- crea un fichero de escritura y lectura. Si ya existe lo crea de nuevo.
ab ---- abre o crea un fichero para escribir al final del mismo.
a+b --- abre o crea un fichero para leer y añadir datos al final del mismo.
rb ---- abre un fichero de lectura.
r+b --- abre un fichero de lectura y escritura.

Escribir en un archivo de texto



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

void main(void){
char d,cade[17]="Hola Como estas?";
int c;
FILE *arch;
clrscr();
	if(!(arch=fopen("archivo.txt","w"))){
	   printf("Error");
	   exit(0);
	}
	else{
	   for(c=0;c<=17;c++){
	      d=cade[c];
	      fputc(d,arch);
	   }
	}
fclose(arch);
	if(!(arch=fopen("archivo.txt","r"))){
	   printf("Error");
	   exit(0);
	}
	else{
	   fgets(cade,18,arch);
	   printf("%s",cade);
	}
fclose(arch);
getch();
}


Al final puedes descargar mas ejemplos de programas manejando archivos en c.

Autor: Gamaliel M.
Introducción

Un puntero es una variable que contiene la dirección de memoria de variable. Se utilizan para pasar información entre una función y sus puntos de llamada.

Existe dos operadores especiales para trabajar con punteros: & y *.

El primero devuelve la dirección de memoria de su operador.
El segundo devuelve el valor de la variable cuya dirección es contenida por el puntero.

Ejemplo con &: formula general.

#include<iostream.h>
#include<conio.h>
#include<math.h>

int formula(int, int, int , float &, float &);

void main(){
  int a, b, c, opc;
  float x1, x2;
  clrscr();
  cout<<"Escribe a: "; cin>>a;
  cout<<"Escribe b: "; cin>>b;
  cout<<"Escribe c: "; cin>>c;
  opc=formula(a,b,c,x1,x2);
  if(opc==1)
    cout<<"No div entre 0.";
  else if(opc==2)
    cout<<"No raiz imaginaria.";
  else
    cout<<"X1 = "<<x1<<endl<<"X2 = "<<x2;
  getch();
}

int formula(int a, int b, int c, float &x1, float &x2){
  float div, rais;
  div=2*a;
  rais=(b*b) - (4*a*c);
  if(div>0){
    if(rais>=0){
	x1=(-b + sqrt(rais))/div;
	x2=(-b - sqrt(rais))/div;
	return 0;
    }
    else
	return 2;
  }
  else
    return 1;
}


Ejemplo con *: área de un triangulo.

#include<stdio.h>
#include<conio.h>

void area(int b,int h,float *a);
void main(void){
int b,h;
float a;
  clrscr();
  printf("

Escribe la base: ");
  scanf("%d",&b);
  printf("Escribe la altura: ");
  scanf("%d",&h);
  area(b,h,&a);
  printf("
 El area es: %.2f",(float)a);
getch();
}

void area(int b,int h,float *a){
  *a = (b*h)/2;
}


Autor: Gamaliel M.
Introducción

Te mostramos este pequeño juego de tirador o tiro al blanco, el juego esta conformado de 5 niveles en donde las pelotas se mueven mas rápido para que tenga una mayor dificultad, en este juego se muestra como utilizar interrupciones para manipular el mouse.

Descarga el juego al final del artículo.

Autor: Gamaliel M.
Introducción

Descarga este divertido juego de damas inglesas echo en c, en este podras aprender algunas cosas de graficos, como manipolar y validar las figuras greficas y algo interesante como utilizar interrupciones para utilizar el mouse.

Al final se encuentra el archivo para que lo descargues.

Autor: Gamaliel M.
« 1/2 2 »