Mensajes

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:

Código (c) [Seleccionar] Expandir

#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.

Otra vez quieres que te digamos lo que pensamos luego sales llorando porque lee cosas no te gustan que te digamos, primero pienso que temas personales, familiares y demás índoles no se debería abrir un debate en foro libre, no por nada porque son asuntos personales de queda persona, nosotros desconocemos a tu familia y el entorno que te rodea para poder dar una Opinión y aunque te la demos de que vale, si luego vas hacer lo que te sale de los huevos.

Ademas no veo que sea preguntas existenciales interesante me parece preguntas muy personales y algunas incluso paranoicas.

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

[MinusFour]

Código (c) [Seleccionar] Expandir

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

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.

Sólo puntualizar una cosa. No es que almacenar el valor de un puntero en un entero como size_t esté mal en sí. Como había dicho antes, a veces se hace; la propia API de Windows es un ejemplo. Pero aunque en todos los sistemas actuales size_t es lo suficientemente grande para guardar direcciones, no hay garantía de que siempre sea así, y en los casos donde no lo sea, el resultado quedaría indefinido (por ejemplo, en DOS de 16 bits, el programa seguramente no funcionaría correctamente, al menos si se compila para modelo compact, large, etc.) por lo que, si no es estrictamente necesario no se debería hacer.

Claro. Por eso le habia dicho al hombre esto:

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

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...

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).

(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.

[otra]

En el dado caso que quisiera usar un puntero de ese tipo... porque no usar:

Código (c) [Seleccionar] Expandir

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

Esta si que es la forma correcta.

Lo peor que puede uno hacer es creerse un experto

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]

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ó?:

Código (c) [Seleccionar] Expandir

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:

Código (c) [Seleccionar] Expandir

_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.

[tamaño]

Gracias ya esta solucionado, ese era el error, sin embargo, no entiendo porque es (GeneralNode *)*((size_t*)aux->data especificamente del size_t.

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:

Código (c) [Seleccionar] Expandir

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

El compilador te va a dar un error:

error: 'void*' is not a pointer-to-object type

Sin embargo, puedes hacerlo con size_t:

Código (c) [Seleccionar] Expandir

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.

[proof]

Código (c) [Seleccionar] Expandir

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.

me esta saliendo basura,

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).

curl funciona en windows.

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?