Mensajes

  Sí, así es  

Yo tampoco he hecho informática. Soy un autodidáctico de la vida  

Una cosa: aunque tu expresión del while es correcta, para el ordenador, para nos debería reflejarse como

Código (c) [Seleccionar] Expandir

while(*s1 && *s2 && (*s1 == *s2))

Recuerda que lo que quieres decir al compilador y a la gente que ve el código es:

Código (c) [Seleccionar] Expandir

while((*s1 != '\0') && (*s2 != '\0') && (*s1 == *s2))

Muy buenas.

En línea 4:

Código (c) [Seleccionar] Expandir

if (!*str2) return 0;
*str2 se puede traducir a str[0]: valor del primer carácter de la cadena str2.
La exclamación que tiene delante niega lógicamente dicho valor. El valor 0 es el único valor que negado hace que un if ejecute las instrucciones asociadas. Por otra parte un valor 0 en una cadena es el carácter nulo ( '\0' ) de fin de cadena que espera C como marcador de fin de cadena.
Todo ello quiere decir que si str2 es una cadena vacía, sólo compuesta por el carácter de fin de cadena ( "\0" ), el la función retornará 0.
La línea 10 hace lo propio con s2.

En la línea 8:

Código (c) [Seleccionar] Expandir

while (*s1 && *s2 && !(*s1 - *s2))
while ejecuta su código asociado siempre que lo que tenga entre paréntesis sea diferente a 0, la forma en C de decir que una expresión es cierta.
El operador AND lógico ( && ) solo le interesa que sus operandos sean 0 o distinto a 0. *s1 y *s2 son un carácter que, para AND, mientras sean distintos a 0, o como ya hemos visto el carácter de fin de cadena, será cierto.
Donde dice !(*s1 - *s2) se restan dos caracteres. Para C lo que se está es restando los valores numéricos que representan esos caracteres (ASCII), si *s1 y *s2 son iguales el resultado aritmético es 0. Y aquí entra a jugar el operador de negación ( ! ): si resulta que son iguales, valor 0 -> falso, se niega y se convierte en verdadero, con lo que para el conjunto de la instrucción hará que while ejecute sus instrucciones asociadas.
Esto quiere decir que: mientras los caracteres de s1 y s2 no sean el carácter nulo y ambos sean iguales while ejecutará sus instrucciones asociadas.

Aunque la función que has dado es rara, porqué sólo indica que ha hay coincidencia o no. La función de librería estándar devuelve el puntero a la primera ocurrencia en str1 de la cadena apuntada por str2 o un puntero NULL en caso de no haber coincidencias.

Muy buenas.

Googleando un poco por ahí he visto que el correo a través de gmail no es tan sencillo. Se espera que se realice una conexión segura y una cifrado base64 del nombre de usuario y contraseña.

Mira el siguiente enlace.

http://stackoverflow.com/questions/11046135/how-to-send-email-using-simple-smtp-commands-via-gmail

Cuándo mandar un correo por telnet, el traducirlo a un programa será pan comido.

Muy buenas!

Espero que te sirva 

Si desarrollas tu idea postea, tengo ganas de verla 

Muy buenas.

Pues la idea es hacer algo parecido a los delegados de C# pero con el C de toda la vida.
Sobre una lista dinámica de diferentes funciones con la misma firma se puede hacer las siguientes operaciones:
· Añadir funciones al final de la lista
· Quitar la primera aparición de una función dada
· Vaciar la lista de una tacada
· Ejecutar todas las funciones de la lista de forma secuencial y con unos parámetros comunes dados en la llamada a la ejecución.

En este programa se trabaja sobre una función que acepta un char* y no devuelve nada, pero se puede modificar fácilmente para trabajar con otras funciones.

Código (c) [Seleccionar] Expandir


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

typedef struct tdelegate {
void (*func)(char*);
struct tdelegate *next;
} DELEGATE;

int delegate_add(DELEGATE **pdelegate, void (*funcpointer)(char*)) {
DELEGATE *newdelegate = malloc(sizeof(DELEGATE));
DELEGATE *aux = NULL;

if(newdelegate == NULL)
return 0;

newdelegate->func = funcpointer;
newdelegate->next = NULL;

if(*pdelegate == NULL)
*pdelegate = newdelegate;
else {
aux = *pdelegate;
while(aux->next != NULL)
aux = aux->next;
aux->next = newdelegate;
}
return 1;
}

void delegate_exec(DELEGATE **pdelegate, char *str) {
DELEGATE *actualdelegate = *pdelegate;

while(actualdelegate != NULL) {
actualdelegate->func(str);
actualdelegate = actualdelegate->next;
}
}

void delegate_del(DELEGATE **pdelegate, void (*funcpointer)(char*)) {
DELEGATE *actualdelegate = *pdelegate;
DELEGATE *aux = NULL;
int found = 0;

if(funcpointer == NULL || actualdelegate == NULL)
return;

if(actualdelegate->func == funcpointer)
{
aux = actualdelegate->next;
free(actualdelegate);
actualdelegate = aux;
}
else {
while(actualdelegate->next != NULL && !found) {
if(actualdelegate->next->func == funcpointer) {
found = 1;
aux = actualdelegate->next->next;
free(actualdelegate->next);
actualdelegate->next = aux;
}
else actualdelegate = actualdelegate->next;
}
}
}

void delegate_free(DELEGATE **pdelegate) {
DELEGATE *aux = NULL;

if(*pdelegate == NULL) return;
while(*pdelegate != NULL) {
aux = (*pdelegate)->next;
free(*pdelegate);
*pdelegate = aux;
}
}

/* FUNCIONES DE PRUEBA */
void a(char *str) {
printf("%p: %s\n", &a, str);
}

void b(char *str) {
printf("%p: %s\n", &b, str);
}

void c(char *str) {
printf("%p: %s\n", &c, str);
}

/* PROGRAMA DE PRUEBA */
int main() {

DELEGATE *midelegado = NULL;

delegate_add(&midelegado, &a);
delegate_add(&midelegado, &b);
delegate_add(&midelegado, &c);

delegate_exec(&midelegado, "hola");

delegate_del(&midelegado, &b);
delegate_exec(&midelegado, "adios");

delegate_free(&midelegado);
midelegado = NULL;

return 0;
}



Muy buenas.

Supongo a que te refieres a que buscas algo como un intérprete de C++. Buscando un poco por internet he encontrado lo siguiente CLIN que es un intérprete de c++, en el sabor de CLAN.
Si quieres algo más tradicional te puedes decantar por make, CMake, o algún IDE que usa esta tecnología. Tal vez te guste QT creator.

Muy buenas.

¿Has realizado algo, como los menus, la estructura de datos, la estructura basica del programa?

Muy buenas.

Si a lo que te refieres a no cambiar el archivo, pues sin guardarlo en dicho archivo seguirá desordenado.
Si te refieres a seguir teniendo el array original desordenado puedes hacerle una copia y trabajar sobre la copia.

Muy buenas.

Ahora que lo he visto, fallo mio. 

Siendo productoArray tu array de productos declarado como

Código (c) [Seleccionar] Expandir

producto productoArray[pLength];

siendo pLength una constante numérica que marca el tamaño de tu array, la llamada a qsort debe ser así:

Código (c) [Seleccionar] Expandir

qsort(productoArray, pLength, sizeof(producto), comparar_producto);

No se si la funcion ordenarProducto debes incluirla obligatoriamente pero no te haría falta porque qsort hace todo el trabajo. Allí donde tengas ordenarProducto pones directamente qsort y tu array se debe ordenar directamente.

Muy buenas.

Código (c) [Seleccionar] Expandir

#include<conio.h>
// conio.h no es una libreria estandar y no funcionara en todos los compiladores.
// ademas no usas ninguna de sus funciones.
#include<stdio.h>
#include <stdlib.h>

struct matrix_x {   
int kick;
int kick2;
char nombre[10];
struct  matrix_x *psiguiente;
};

struct matrix_x *pprimero;
struct matrix_x *pultimo;
int i = 0; // Una variable global que no usas

void insertar (int dato, char nombre[], int codigo) {

struct  matrix_x * paux;

paux = (struct matrix_x*)malloc(sizeof(struct  matrix_x));   

if(paux == NULL)
{         
printf("error en la memoria ");
}
else
{
paux->kick = dato;
paux->kick2 = codigo;
paux->nombre = nombre; // Debes los datos, no la direccion de los datos -> strncpy(paux->nombre, nombre, 10);
paux->psiguiente = NULL;

if (pprimero == NULL)
{
pprimero = paux;
pultimo = paux;   
}
else
{
pultimo->psiguiente = paux;
pultimo = paux;
}
}
i++;
}

void mostrar () {
struct matrix_x *aux;
aux = (struct matrix_x*)malloc(sizeof (struct  matrix_x)); // Esta linea no la necesitas
aux = pprimero; // pues aqui haces que aux apunte a pprimero abandonado la memoria apuntada anteriormente. Malo porque hay memoria asignada que no podras recuperar.
int i = 0; // ocultas la variable i global
while (aux != NULL){
printf ("\n dato___%d       codigo___%d  ",aux->kick,aux->kick2);
fflush(stdin); // fflush espera un flujo de salida. Esto no funcionara en todos los compiladores o SS.OO.
printf ("\n  nombre %s",aux->nombre);
fflush(stdin); // otra vez el mal uso de fflush
aux = aux->psiguiente;
i++; // incrementas i local, pero no la usas
}
}
     
int main() {
int cx = 0;
int dato, codigo;
char  nombre[10];
printf("Introduzca cero para continuar\n"); //
while(dato != 0 && codigo != 0 && nombre != 0) {
fflush(stdin); // otra vez el mal uso de fflush
printf ("dame dato_%d____",cx);
scanf ("%d",&dato);
printf ("dame codigo_%d___",cx);
scanf ("%d",&codigo );
printf ("dame nombre _%d___",cx);
fflush(stdin); // otra vez el mal uso de fflush
scanf ("%s",&nombre[cx] ); // varios fallos aquí -> scanf("%s", nombre);
insertar(dato,nombre,codigo);
cx=cx+1; // mas correcto usar ++cx. Por otra parte enganas al usuario, pues aunque insertar falle
// al adquirir memoria con malloc y no introduzca el dato, incrementas cx sin que el dato
// anterior se haya introducido, falseando asi el numero de datos introducidos.
}
mostrar();
printf ("has salido del programa");
// deberias incluir una función para liberar la memoria
// que has adquirido con cada uno de los malloc en insertar.

// main debe devolver un valor: el S.O. espera que devuelva 0 si el programa ha terminado con exito.
}