Mensajes

Interesante lo que comentas  crack81, yo nunca use pascal.

MAFUS es de los que piensan como yo.

Lo unico que le envidio a C++ es la facilidad de concatenar cadenas, tengo mi propia implementacion con funcion de argumentos variables...

Código (c) [Seleccionar] Expandir

char *funcion(char *format,...){
..
}

En el trabajo actualmente programo en C# bajo windows y llegando a mi caso en C bajo FreeBSD XD.

Saludos.

Gracias Eternal Idol ya estoy enterado , tu siempre tan meticuloso con los estándares 

Aun asi la implementacion de realloc que me toco ver coincide con que es mas eficiente dejar la memoria tal cual en ese caso especifico.

Saludos a todos!

Acabo de confirmar al revisar el codigo fuente derealloc y si el espacio de memoria solicitado es menor que el anterior NO mueve ningun byte de memoria, solo actualiza en su lista de punteros que el puntero dado utiliza menos memoria.

Lo pueden revisar en
http://www.scs.stanford.edu/histar/src/pkg/uclibc/libc/stdlib/malloc-standard/realloc.c

La parte en cuestion es esta:

Código (c) [Seleccionar] Expandir


if ((unsigned long)(oldsize) >= (unsigned long)(nb)) {
    /* already big enough; split below */
    newp = oldp;
    newsize = oldsize;
}

else {
...


Es un problema de programación en paralelo y se debe de aplicar un semáforo, te puedo ayudar mándame un DM.

Si es la misma, depende de la implementan de realloc, en teoria lo mas eficiente es dejar la misma dirección cuando el espacio que se va asignar es menor al previo.

Código [Seleccionar] Expandir

string1 Valor: 0000000000321380 [0123456789AB]
string2 Valor: 0000000000321380 [0123456789AB]

Este post es totalmente offtopic del foro de Programacion C/C++

Las discuciones entre programadores que giran en torno al lenguaje C y sus derivados siempre son por temas un tanto tontos como si:

Código (c) [Seleccionar] Expandir

void funcion() {
}

Código (c) [Seleccionar] Expandir

void funcion()
{
}

Que si espacio o tabulador, que si funciones o metodos que si unsigned o signed, que si new o malloc, que si malloc o calloc en fin..

Cuando aprendi programación iniciamos con orientado a objetos y despues ejemplos en C estandar y me agradaban mas los ejemplos sencillos en C, me gustaba tener mas control de la memoria y programar a mas bajo nivel.

A muchos no les gusta o no entienden los punteros o que se yo tal vez vienen de algun lenguaje de mas alto nivel cómo VB o de algun lenguaje script donde no se preocupan tanto por la memoria o los tipos de datos.

He aprendido muchos lenguajes tanto VB como C sharp, Java, Ensamblador, PHP, y varios lenguajes script puedo decir que todos tienen sus pro y sos contra, aun asi NO me canso de programar en C, hay veces que he tenido fricciones con compañeros por la forma en la que programo me dicen usa esto o has esto y la verdad yo nunca les he dicho com programar en fin...

Yo prefiero usar Tabuladores para separar.

¿Tienen ustedes fricciones por como programan o alguna vez le han dicho a alguien mas que mejor use una función u otra?

Como comenta MAFUS el string1 deja de tener memoria asignada...

aun asi el string1 sigue apuntando a la direccion que originalmente se le asigno y los datos que estaban ahi ahi siguen... el sistema operativo es el que se encarga de ver si lo borra lo asigna o que se yo..

Es deber del usuario no usar ese puntero hasta que se reasigne nuevamente. La memoria que originalmente se asigno podria ser designada a otro apuntador.

Si el apuntador se va a volve a usar hay que igualarlo a NULL para que no nos de un error despues al hacer

if(string1)....

mas info:
http://linux.die.net/man/3/realloc

[Números de longitud variable en C (Numeros muy grandes)]

En su momento mas de alguno uso el operador modulo

r = a % n;

donde r es el resto de la división a/n donde n != 0

Ahora como estoy trabajando con numeros muy grandes de longitud variable el operador modulo como tal no me sirve, necesito crear la funcion que haga el modulo manualmente.

Si alguno de ustedes se perdio los temas, estos son algunos de ellos

Números de longitud variable en C (Numeros muy grandes)
Restas manuales en "Binario"

Ahora si hacemos la funcion modulo en forma de restas, tenemos solo le tenemos que restar al numero a el valor de n hastra que a sea menor que n

El siguiente codigo es muestra de ello de forma manual y sin ninguna optimizacion.

Código (c) [Seleccionar] Expandir

#include<stdio.h>

int main() {
int resto,a,n,contador;
a = 9999998;
n = 3;
resto = a;
contador = 0;
while(resto >= n) {
resto-= n;
contador++;
}
printf("resto: %u\nVeces en el ciclo %u\n",resto,contador);
}

Salida:

Código [Seleccionar] Expandir

resto: 2
Veces en el ciclo 3333332


Como vemos el numero de veces que entra al ciclo es el resultado de la división obtenido de forma iterativa mediante restas sucesivas.

Pero como se trata solo de la función "Modulo" o "Resto" no nos interesa el resultado de la división, para fines prácticos y rápidos realice esa función un poco mas optimizada y se podría optimizar mas, pero ya lo dejo a su consideración.

Código (c) [Seleccionar] Expandir

#include<stdio.h>

int main() {
int resto,a,n,contador,n_pivote,resto_pivote,entrar;
a = 9999998;
n = 3;
resto = a;
contador = 0;
resto_pivote = resto;
n_pivote = n;
entrar = 1;
while(entrar && resto >= n) {
resto_pivote-=n_pivote;
if(resto_pivote>=0) {
resto = resto_pivote;
n_pivote*=2;
}
else {
if(n_pivote > n) {
n_pivote/=2;
resto_pivote = resto;
}
else {
entrar = 0;
}
}
contador++;
}
printf("resto: %u\nVeces en el ciclo %u\n",resto,contador);
}

Salida:

Código [Seleccionar] Expandir


resto: 2
Veces en el ciclo 65


Como vemos el numero de veces que entra es muchísimo menor incluso si optimizamos mas la función para este ejemplo podremos llegar hasta solo 55 o 58 veces entrando al ciclo dado.

El programa utilizada una aproximación binaria ya que en cada iteracion al numero a se le resta un valor igual a n*2 veces la cantidad del ciclo anterior.

Dado que estoy trabajando con numero descomunalmente grandes... cualquier optimizan en estas funciones es mas que bien recibida.

Saludos!



Optimize aun mas el Código y ahora solo se ejecuta 42 veces para el ejemplo dado.

Ahora en lugar de incrementar el sustraendo dentro del ciclo principal lo incremento al máximo en un ciclo aparte antes del principal y posteriormente dentro del ciclo principal lo decremento hasta que sea el un multiplo de n inmediamtamente menor al valor actual de r

Código (c) [Seleccionar] Expandir

#include<stdio.h>

int main() {
int resto,a,n,contador,n_pivote,entrar;
a = 9999998;
n = 3;
resto = a;
contador = 0;
n_pivote = n;
entrar = 1;
while(n_pivote<resto) {
n_pivote+=n_pivote;
contador++;
}
while(entrar && resto >= n) {
while(n_pivote>resto && n_pivote>n) {
n_pivote/=2;
contador++;
}
resto-=n_pivote;
}
printf("resto: %u\nVeces en el ciclo %u\n",resto,contador);
}

Salida:

Código [Seleccionar] Expandir

resto: 2
Veces en el ciclo 42


Considero yo que es el mas optimizado pero no se tal vez se puede ahorrar alguno que otro ciclo, la variable contador solo es para fines didácticos.

Saludos

[Complemento dos 0x100]

Gracias MAFUS por tu respuesta, leeré los temas que comentas para aplicar las restas.

Saludos!



Muy buen dia otra vez.

Tengo ahora una intriga sobre el compilador... pero veamos

La definición de complemento a 2 esta dada por 2^n - N donde n es el  numero de bits del numero dado N al que se le quiere sacar complemento, solución Método alterno sacar complemento 1 y sumarle 1 que es mas facil ~N +1

Código (c) [Seleccionar] Expandir

#include<stdio.h>

int main() {
unsigned char a,c;
unsigned short b;

a = 0xF0;
printf("Nunmero orignal 0x%.2x\n",a);
a = ~a;
printf("Complemento uno 0x%.2x\n",a);
b = a + 1;
c = b >> 8;
printf("Complemento dos 0x%.2x\n",b);
printf("? Acarreo : 0x%.2x\n",c);
a = 0xFF;
printf("Nunmero orignal 0x%.2x\n",a);
a = ~a;
printf("Complemento uno 0x%.2x\n",a);
b = a + 1;
c = b >> 8;
printf("Complemento dos 0x%.2x\n",b);
printf("? Acarreo : 0x%.2x\n",c);
a = 0x00;
printf("Nunmero orignal 0x%.2x\n",a);
a = ~a;
printf("Complemento uno 0x%.2x\n",a);
b = a + 1;
c = b >> 8;
printf("Complemento dos 0x%.2x\n",b);
printf("? Acarreo : 0x%.2x\n",c);
}

El codigo anterior me da la salida:

Código [Seleccionar] Expandir


Nunmero orignal 0xf0
Complemento uno 0x0f
Complemento dos 0x10
? Acarreo : 0x00
Nunmero orignal 0xff
Complemento uno 0x00
Complemento dos 0x01
? Acarreo : 0x00
Nunmero orignal 0x00
Complemento uno 0xff
Complemento dos 0x100
? Acarreo : 0x01


Lo que me intriga es:

Complemento dos 0x100

Que viene de la linea :

printf("Complemento dos 0x%.2x\n",b);

b es un short pero el formato de cadena es %.2x por lo cual solo me debería de mostrar los primeros 2 hexadecimales correspondientes al primer byte del numero short, en fin... no es problema realmente puedo usar posiciones de memoria para extraer solo el numero que me interesa, solo que me intrigo que no respeto el formato de la cadena...

ahora solo me queda hacer la... resta que quiero usando sumas xD jajajajaja con complemento a 2 en el sustraendo, todavía no la hago pero tengo que ver bien como es el proceso a nivel de bit, lo voy a hacer ahora si en el cuaderno para darme una idea real de que pasa....

Saludos!

[Mi problema ahora son las restas.]

Gracias boctulus y de hecho asi lo hice con las potencias:

Numero 65535

6 x10^4 : numeros[0]->valor: 0x451410 60ea
5 x10^3 : numeros[1]->valor: 0x451510 8813
5 x10^2 : numeros[2]->valor: 0x4514a0 f401
3 x10^1 : numeros[3]->valor: 0x451530 1e
5 x10^0 : numeros[4]->valor: 0x4513e0 05

Separe cada numero de la cadena y lo convertí a su numero en potencia de 10 y posteriormente sume los números individuales.

Mi problema ahora son las restas. como dice el titulo del post.