Mensajes

Mira tanto ATI como Nvidia son buenas placas es como tener
AMD, Intel
yo tengo una ATI HD y andan muy bien puedo coreer el Modern warfare 2 con los graficos a ful y ni se esfuerza

Lo sé pero tengo que elegir entre esas dos placas, ya que como mencioné, debo trabajar con tecnología cuda

Lo que sucede es que necesito trabajar con tecnología cuda...

Que tal, que tarjeta recomendarían comprar entre estas dos?

ZOTAC GeForce GTX 465
EVGA GeForce GTX 460 SE

Bien el problema radicaba en que estaba haciendo un realloc() en i+1, y luego de haber reservado la memoria, yo estaba haciendo un postincremento, con el cual asignaba a la lista una cadena en memoria que no estaba reservada... Basta cambiar el postincremento... Era cuestión de lógica 

No entiendo esta pregunta:

sabiendo que &m es la direccion de memoria de m , como se hace para la funcion?

¿Quieres saber como devolver la dirección de x con "funcion"? o ¿quieres saber la dirección de la funcion?

Hola xafirot, compilado con g++ funciona sin problemas sólo dando el warning al retorno de la dirección...

Código (cpp) [Seleccionar] Expandir

#include <iostream>

char *foo( void );
int foo2( void );
int *dir( void );

int main()
{
std::cout << "foo:";
std::cout << foo() << std::endl;
std::cout << "foo2:";
std::cout << foo2() << std::endl;
std::cout << "dir:";
std::cout << dir() << std::endl;
}

char *foo( void )
{
return "HOLA MUNDO";
}

int foo2( void )
{
return 0;
}

int *dir( void )
{
int x = 10;
std::cout << "LA DIRECCION DE x es:" << &x << std::endl;
return &x;
}

Código [Seleccionar] Expandir


facu@linux:~/Escritorio$ ./a.out
foo:HOLA MUNDO
foo2:0
dir:LA DIRECCION DE x es:0xbfe2587c
0xbfe2587c


EDITADO: Gracias por la página!
Justamente, estaba tratando de hacer y luego de leer un poco sobre punteros a punteros en c, y reservación de memoria llegué al siguiente código, pero tengo un problema:

Código (c) [Seleccionar] Expandir

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

char **split ( const char *s1, const char *s2) {

   char **lista;
   char *aux = s1;
   char *token_Ptr;
   int i = 0;
   
   lista = (char **) malloc (sizeof (char *));
   token_Ptr = strtok(aux, s2);
   lista[i] = token_Ptr;
   while(token_Ptr != NULL)
   {
       lista = (char **)realloc(lista, sizeof(char*) * (i + 1));
       token_Ptr = strtok(NULL, s2);
       i++;
       lista[i] = token_Ptr;
   }
   return lista;
}

int main ( int argc , char *argv[]) {

   char **MILISTA;
   int i;

   if (argc==2) {
       printf ("Cadena: '%s'\n",argv[1]);
       MILISTA= split(argv[1]," ");
       i=0;
       puts("----------------TOKENS------------");
       while (MILISTA[i]!=NULL) {
           printf("%s, " , MILISTA[i++]);
       }
       printf("\n");
       puts("----------------FIN---------------");
   }
   return 0;
}

Código [Seleccionar] Expandir

facu@linux:~/projects/spliting/bin/Debug$ ./spliting "HOLA MUNDO COMO s"
Cadena: 'HOLA MUNDO COMO s'
*** glibc detected *** ./spliting: realloc(): invalid next size: 0x09e12008 ***
======= Backtrace: =========
/lib/libc.so.6(+0x6c501)[0x17c501]
/lib/libc.so.6(+0x71c6d)[0x181c6d]
/lib/libc.so.6(realloc+0xe3)[0x181f53]
./spliting[0x8048573]
./spliting[0x80485fa]
/lib/libc.so.6(__libc_start_main+0xe7)[0x126ce7]
./spliting[0x8048471]
======= Memory map: ========
00110000-00267000 r-xp 00000000 08:06 8526       /lib/libc-2.12.1.so
00267000-00269000 r--p 00157000 08:06 8526       /lib/libc-2.12.1.so
00269000-0026a000 rw-p 00159000 08:06 8526       /lib/libc-2.12.1.so
0026a000-0026d000 rw-p 00000000 00:00 0
00573000-0058d000 r-xp 00000000 08:06 251        /lib/libgcc_s.so.1
0058d000-0058e000 r--p 00019000 08:06 251        /lib/libgcc_s.so.1
0058e000-0058f000 rw-p 0001a000 08:06 251        /lib/libgcc_s.so.1
0065a000-0065b000 r-xp 00000000 00:00 0          [vdso]
007f1000-00815000 r-xp 00000000 08:06 8577       /lib/libm-2.12.1.so
00815000-00816000 r--p 00023000 08:06 8577       /lib/libm-2.12.1.so
00816000-00817000 rw-p 00024000 08:06 8577       /lib/libm-2.12.1.so
00c2d000-00d0c000 r-xp 00000000 08:06 660319     /usr/lib/libstdc++.so.6.0.14
00d0c000-00d10000 r--p 000de000 08:06 660319     /usr/lib/libstdc++.so.6.0.14
00d10000-00d11000 rw-p 000e2000 08:06 660319     /usr/lib/libstdc++.so.6.0.14
00d11000-00d18000 rw-p 00000000 00:00 0
00e86000-00ea2000 r-xp 00000000 08:06 8518       /lib/ld-2.12.1.so
00ea2000-00ea3000 r--p 0001b000 08:06 8518       /lib/ld-2.12.1.so
00ea3000-00ea4000 rw-p 0001c000 08:06 8518       /lib/ld-2.12.1.so
08048000-08049000 r-xp 00000000 08:08 262453     /home/facu/projects/spliting/bin/Debug/spliting
08049000-0804a000 r--p 00000000 08:08 262453     /home/facu/projects/spliting/bin/Debug/spliting
0804a000-0804b000 rw-p 00001000 08:08 262453     /home/facu/projects/spliting/bin/Debug/spliting
09e12000-09e33000 rw-p 00000000 00:00 0          [heap]
b7700000-b7721000 rw-p 00000000 00:00 0
b7721000-b7800000 ---p 00000000 00:00 0
b7870000-b7873000 rw-p 00000000 00:00 0
b7888000-b788b000 rw-p 00000000 00:00 0
bf834000-bf855000 rw-p 00000000 00:00 0          [stack]
Abortado

Que tal, hace un tiempo trato de buscar una función split como la gente y no la encuentro... Y tampoco se me ocurre la forma de hacerla...

La elaboración de la función no es muy complicada, solo basta almacenar los tokens devueltos por strtok() o strsep() en un array... Y luego devolverlos, la cabecera de la función sería algo así:

Código (c) [Seleccionar] Expandir

char **split( const char *s1, const char *s2 );

Supongamos que en el main tenemos declarado:

Código (c) [Seleccionar] Expandir

char **tokens;

La asignación sería:

Código (c) [Seleccionar] Expandir

tokens = split( cadena, delimitador );

Pero previamente se debería haber reservado espacio para los tokens, y he aquí el problema, ya que ¿cómo sabremos la cantidad de tokens? ¿y el tamaño de cada una de ellos?... Podríamos reservar un espacio constante, pero podríamos desperdiciar memoria, o caer en un "segmentation fault" si faltase... ¿Cómo hacen otros lenguajes para hacer eficiente esta función?

Qué les parece este ejercicio que me tocó hacer? Tienen alguna mejora?

Código (c) [Seleccionar] Expandir

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

/** Algoritmo que cuenta la cantidad de cadenas
dentro de otra cadena **/

typedef unsigned int ui;
ui cuenta_str(const char *, const char *);

int main()
{
   char *cadena = "¿MUNDO? MUNDO, SOY EL DIOS DEL MUNDO, MUNDO DOMINARE";
   char *subcad = "MUNDO";
   ui cuenta = cuenta_str(cadena, subcad);
   printf("La cantidad de veces que %s se repite en %s es: %d", subcad, cadena, cuenta);
   return 0;
}

ui cuenta_str(const char *s1, const char *s2)
{
   const char *delim = " ,.!¡¿?/-";
   char *aux = malloc(sizeof(char) * strlen(s1) + 1);
   char *token_Ptr;
   ui cnt = 0;
   if(s1 == NULL)
       return 0;
   strcpy(aux, s1);
   token_Ptr = strtok(aux, delim);
   while(token_Ptr != NULL)
   {
       if(strcmp(token_Ptr, s2) == 0)
           cnt++;
       token_Ptr = strtok(NULL, delim);
   }
   return cnt;
}

Debería liberar la memoria de aux cierto?

EDITADO: Debería también contar MUNDO en la cadena "MUNDOROLA"? creen que sea necesario? Digamos que asumí que cadena = palabra

Tal vez te sirva esto   

Código (c) [Seleccionar] Expandir

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

typedef struct _nodo {
   int dni;
   int fecha;
   struct _nodo *siguiente;
} tipoNodo;

typedef tipoNodo *pNodo;
typedef tipoNodo *Lista;

/* Funciones con listas: */
void Insertar(Lista *l, int d, int f);
void Borrar(Lista *l, int d);

int ListaVacia(Lista l);

void BorrarLista(Lista *);
void MostrarLista(Lista l);

void list_fic(Lista L);
void leer_fic();

int main()
{
   Lista lista = NULL;
   pNodo p;

   Insertar(&lista, 1111, 11 );
   Insertar(&lista, 2222, 22);


   MostrarLista(lista);
   list_fic(lista);
   leer_fic();
   return 0;
}

void Insertar(Lista *lista, int d, int f)
{
   pNodo nuevo, anterior;

   /* Crear un nodo nuevo */
   nuevo = (pNodo)malloc(sizeof(tipoNodo));
   nuevo->dni = d;
   nuevo->fecha = f;

   /* Si la lista está vacía */
   if(ListaVacia(*lista) || (*lista)->dni > d) {
      /* Añadimos la lista a continuación del nuevo nodo */
      nuevo->siguiente = *lista;
      /* Ahora, el comienzo de nuestra lista es en nuevo nodo */
      *lista = nuevo;
   }
   else {
      /* Buscar el nodo de valor menor a v */
      anterior = *lista;
      /* Avanzamos hasta el último elemento o hasta que el siguiente tenga
         un valor mayor que v */
      while(anterior->siguiente && anterior->siguiente->dni <= d)
         anterior = anterior->siguiente;
      /* Insertamos el nuevo nodo después del nodo anterior */
      nuevo->siguiente = anterior->siguiente;
      anterior->siguiente = nuevo;
   }
}

void Borrar(Lista *lista, int d)
{
   pNodo anterior, nodo;

   nodo = *lista;
   anterior = NULL;
   while(nodo && nodo->dni < d ) {
      anterior = nodo;
      nodo = nodo->siguiente;
   }
   if(!nodo || nodo->dni != d) return;
   else { /* Borrar el nodo */
      if(!anterior) /* Primer elemento */
         *lista = nodo->siguiente;
      else  /* un elemento cualquiera */
         anterior->siguiente = nodo->siguiente;
      free(nodo);
   }
}

int ListaVacia(Lista lista)
{
   return (lista == NULL);
}

void BorrarLista(Lista *lista)
{
   pNodo nodo;

   while(*lista) {
      nodo = *lista;
      *lista = nodo->siguiente;
      free(nodo);
   }
}

void MostrarLista(Lista lista)
{
   pNodo nodo = lista;

   if(ListaVacia(lista)) printf("Lista vacía\n");
   else {
      while(nodo) {
         printf("DNI-> %d -> ", nodo->dni);
         printf("FECHA-> %d -> ", nodo->fecha);
         nodo = nodo->siguiente;
     }
     printf("\n");
   }
}

void list_fic(Lista L)
{
FILE *fp;
tipoNodo *aux;

int b = 0;
fp = fopen("pacientes.txt","wb");
aux = L;

while(aux != NULL)
{
  b = fwrite(&aux,sizeof(tipoNodo),1,fp);
  aux = aux->siguiente;
}

fclose (fp);
}

void leer_fic(){
FILE *fp;
tipoNodo *aux;

fp = fopen("pacientes.txt","r+b");

fread(&aux,sizeof(tipoNodo),1,fp);

fclose (fp);
puts("LECTURA!");
printf("DNI:%d\n",aux->dni);
printf("FECHA:%d\n",aux->fecha);
puts("FIN DE LECTURA");
}

Código [Seleccionar] Expandir

./listas
DNI-> 1111 -> FECHA-> 11 -> DNI-> 2222 -> FECHA-> 22 ->
LECTURA!
DNI:1111
FECHA:11
FIN DE LECTURA