Hola,

Queria saber si alguien conoce algun comando avanzado de Google o algo parecido que resulte en la omision de los sitios ya visitados (los que aparecen en color morado, en vez de azul) en la busqueda de Google.

Gracias y saludos,
marax.

Tengo este codigo:

#include <stdio.h>
#include "curl/include/curl/curl.h"
 
size_t dataSize=0;
size_t curlWriteFunction(void* ptr, size_t size/*always==1*/,
                         size_t nmemb, void* userdata)
{
    char** stringToWrite=(char**)userdata;
    const char* input=(const char*)ptr;
    if(nmemb==0) return 0;
    if(!*stringToWrite)
        *stringToWrite=malloc(nmemb+1);
    else
        *stringToWrite=realloc(*stringToWrite, dataSize+nmemb+1);
    memcpy(*stringToWrite+dataSize, input, nmemb);
    dataSize+=nmemb;
    (*stringToWrite)[dataSize]='\0';
    return nmemb;
}
 
int main()
{
    char* data=0;
    CURL*const curl=curl_easy_init();
    if(!curl)
    {
        fprintf(stderr, "error: Initialization");
        return 1;
    }
    curl_easy_setopt(curl, CURLOPT_URL, "http://www.google.com");
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &data);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &curlWriteFunction);
    if(curl_easy_perform(curl)!=CURLE_OK)
    {
        fprintf(stderr, "error: get web page\n");
        return 1;
    }
    curl_easy_cleanup(curl);
 
    if(!data)
    {
        fprintf(stderr, "error: Got no data\n");
        return 1;
    }
 
    printf("Page data:\n\n%s\n", data);
    free(data);
}
 

En Linux, al especificar https: en el URL, no hace ninguna diferencia, sin embargo cuando lo hago en Windows falla la funcion curl_easy_perform. ¿Alguien tiene idea de por que?

Gracias y saludos,
marax.

Apuesto a que no te crees que alguien sea capaz de exponer su intimidad con tal de un poco de atencion, amigo andaluz.

Quise decir: Si contestaste a mi explicacion antes de probar/depurar o al menos echarle un vistazo a la logica de mi planteamiento, entonces...
Nada mas.


Claro. Por eso le habia dicho al hombre esto:


El no esta haciendo nada serio. Tu has dicho que eres un habil experto en C. Me imagino que has jugado con el lenguaje de esta forma en el pasado, y eso ha jugado a su vez un papel importante en tu desarrollo. Si no, si eres mas ortodoxo, y en verdad valoras tu tiempo, olvida este hilo porque nunca nos vamos a entender.

Respecto al direccionamiento, eso tambien se lo mencione...

(direccionable dentro de tu programa)

De hecho, lo que si que no se es hasta que punto size_t* puede direccionar la memoria. ¿Hablas del caso en que una direccion contenga ademas un segmento?

Hola,

Me parece prudente comentar que he llegado hasta esta duda a partir de la curiosidad por el fenomeno del magnetismo y de las llamadas lineas de campo magnetico.

Segun la fisica moderna, el magnetismo no es una fuerza que se ejerce sino una interaccion entre bosones. Es decir que la interaccion resulta por el momento de un boson, y esto a su vez es lo que hace que se repelan los imanes.
Sin embargo esto me presenta algunas curiosidades, y me pregunto si alguno sabe las respuestas, y decirmelas si no es ninguna molestia:

¿que es un polo entonces?
Segun la definicion de polo hablamos de en donde se concentra la mayoria de la energia de algo. Antes de que parezca que estoy dando la respuesta en la pregunta... de esta manera, ¿cual es la diferencia entre polos opuestos? ¿que mientras uno emite bosones el otro los absorbe (por asi decirlo)?
Y si es asi, ¿que tiene que ver que uno emita y el otro los absorba, con la manifestacion del movimiento en el mundo real? Me he hecho un modelo mental para intentar contestarme a mi mismo esta pregunta y resulto lo siguiente (hecho en Paint):



Entonces, ¿recae la diferencia en que el hecho de que una de las particulas absorba fotones (digamos que el espaciotiempo de los bosones funciona asi, si, me refiero a la mecanica/dinamica cuantica) afecta el espaciotiempo de cierta manera en la que la segunda particula queda atraida (la que absorbe)? es decir, ¿estoy en lo correcto?. Y esto podria ser representado en un modelo matematico con la definicion newtoniana de aceleracion, ¿verdad?.

Tal vez parezca engorroso... se ve mejor en mi cabeza. Si alguien intuye tener la respuesta pero se pierde en el caos que solo pregunte...

Gracias de antemano y saludos.

Esta si que es la forma correcta.


Perdoname hacer uso de tu precioso tiempo respondiendo esta cita:

Tienes razon pero no me creo un experto. Lo que crei fue que tu le estabas demostrando otra forma de hacerlo intentando menospreciar la mia, solo otra, y no otra correcta. Hay muchos arrogantes por aqui.

PD: Me jode mas el ego que alguien crea que me la estoy tirando de experto, a que me demuestren que no soy un experto.

RayR, creo que no entendiste el problema del hombre. El quería hacer un casting correcto de un valor que definió como (void *). Este tipo de dato no puede ser accedido directamente, así que use (size_t *) (Ojo, size_t* y no size_t) como un intermediario al dato.

¿Al menos sabes por qué la solución que le di le funcionó?:

 GeneralNode *tmp =(GeneralNode *)*((size_t*)aux->data); 

---

PD: Si el dato es void* como en este caso y sin embargo se insiste en un tipo especifico que puede variar con el tiempo (pues esa es la razon por la que existen punteros void*) se puede incluso indexar un array en un sentido general:

_t *x=(_t*)((size_t*)addr)+sizeof(_t)*i;

---

PD 2: Esta claro que pudo haber hecho su programa mucho mas eficientemente, pero la pregunta que tenia era como hacer el casting correctamente. Esa es la forma. Luego se dara cuenta de por que es mejor algo mas simple, mientras tanto no creo que preste atencion a eso.

Lo que "es" size_t no es aux->data. Lo que es de tamaño size_t es la palabra de tu computador.
https://es.wikipedia.org/wiki/Palabra_(inform%C3%A1tica)

Te equivocaste en dos cosas:

1. Accediste a la direccion de un dato, pensando que era el dato mismo. Esto te ha pasado por no mantener un registro mental o escrito de tus punteros. Aqui estas usando una variedad de punteros, innecesarios en cierta manera como añadio MinusFour, sin embargo entiendo que estas experimentando... cosa que yo veo imprescindible para hacerse habil con este tema.
2. Hiciste un casting equivocado segun la logica de tu programa, por lo que aunque hubieses accedido al dato correcto, habrias estado desalineado [https://en.wikipedia.org/wiki/Data_structure_alignment] y habrias accedido a un dato, pero incorrecto.

Con size_t se puede arreglar el problema del alineamiento. ¿Por que? Porque no size_t en si, sino (size_t *) es algo asi como un puntero (void *) pero accesible. Si tu haces esto:

int x;
void *p;
p=(void *)&x;
*p=1;

El compilador te va a dar un error:

Sin embargo, puedes hacerlo con size_t:

int x;
size_t *p;
p=(size_t *)&x;
*p=1;

Y lo compila perfectamente.

size_t digamos que lo uso como un intermediario, no como un tipo.
Lee los archivos que he enlazado y te daras cuenta de que hay varias formas de llegar a eso.

Saludos.

GeneralNode *tmp =(GeneralNode *)*((size_t*)aux->data); 

Intenta recordar a que exactamente apuntan tus punteros en cada momento dado mientras programas. Si no te toparas con problemas.
Saludos.

---

PD: Si fuera basura luego de cierta cantidad de intentos el programa se hubiese detenido. Sin embargo a medida que compilas te das cuenta de que la cantidad que esta retornando varia en un rango especifico. Esas suelen ser las direcciones que reserva Windows para con la memoria.
Lo que esta imprimiendo printf en tu programa original no es basura, era la direccion de tu variable proof en memoria, con menos precision a causa del casting que hiciste al tipo GeneralNode. size_t es adecuado para estos casos porque se identifica como palabra, es decir, puede contener una direccion a cualquier parte de la memoria (direccionable dentro de tu programa).

Te juro que lo intente utilizar al menos siete veces. Descargue las librerias pero por alguna razon no compila. ¿Tendras acceso a alguna guia o algo asi?