Sí, pretendía tocar el tema de las operaciones con bits, pero debido a que es un poco mas "difícil" de entender, y realmente, en aspectos de programación en general casi nunca se tocan, lo había dejado para el final.
Sigo sin internet, pero hoy voy a escribir un poco mientras no vuelvan mis padres.
Os dejo un regalo (os agradecería que, aparte de mirar el código, leyerais este pequeño párrafo)Durante el tiempo que he estado sin internet, he hecho una cosilla que puede ayudar a alguien.
Alguien sabe lo que son los vectores en C++? Viene a ser una array de C pero dinámicas, no hace falta incluir ninguna delimitacion/tamaño ([x]) y simplemente se pueden ir añadiendo variables en ella.
He hecho algo parecido en C, le falta muchísima optimización, pues hay muchas rutinas repetitivas que se podrían simplificar. Leeros los comentarios que aparecen por allí. También os interesara los múltiples "type casting" que se hacen, las conversiones entre tipos de variables, y lo que a mi más me gusto: como obtener la dirección de un parametro de una función cuando se usa (...) como parametro (mirad la función pushConvertStruct() de la class _ARRAY). Aun no lo hemos tratado en el tutorial, pero también aparece el concepto de class.
La función push() cuando se usa char* (tipo de variable 4, como veréis cuando leáis el código) se tiene que optimizar muchísimo, de hecho, lo ideal sería hacer lo mismo que se hace con el "pushConvertStruct()", es decir, guardar la dirección a la cadena de char, y no los chars.
En la función main() podéis ver el funcionamiento al completo y comentado de la class.
En fin, sin más preámbulos:
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
class _ARRAY{
private:
int varType;
int itemsCount;
int currentSize;
int subItemsCount;
char customStruct[200];
int structSize;
int structPos;
int structItem;
int itemsPerPos;
void *bufferHolder;
int *charIndex;
void *toReturn;
public:
/*
varType:
1: INT
2: FLOAT
3: DOUBLE
4: CHAR
5: CUSTOM (STRUCT)
*/
_ARRAY(int _varType){
this->varType = _varType;
this->clear();
}
//Para efectuar un mejor clear() se debería usar free()
void clear(){
this->bufferHolder = NULL;
this->charIndex = NULL;
this->toReturn = NULL;
this->itemsCount = 0;
this->subItemsCount = 0;
this->currentSize = 0;
this->structSize = 0;
this->structPos = 0;
this->structItem = 0;
this->itemsPerPos = 0;
strcpy(customStruct, "");
}
//Función para establecer el tamaño de la structure
void setStructSize(int _structSize){
this->structSize = _structSize;
}
//Función para convertir una structure a array
void pushConvertStruct(char *fmt, ...){
if(varType != 5)
return;
unsigned long argPos = (unsigned long)(&fmt);
int fmtLen = strlen(fmt);
int readding = 1;
int i = 0;
int readChar = 0;
int readSize = 0;
while(readding = 1 && i < fmtLen){
readSize = 0;
if(readChar){
switch(fmt[i]){
case 'c':
case 'd':{
if(itemsCount==0){
strcat(customStruct, "%d");
itemsPerPos++;
}
currentSize += 4;
if(bufferHolder == NULL)
bufferHolder = malloc(currentSize);
else
bufferHolder = realloc(bufferHolder, currentSize);
argPos = (argPos+(unsigned long)sizeof(long));
((int*)bufferHolder)[subItemsCount] = *(int*)argPos;
subItemsCount++;
}break;
case 'f':{
if(itemsCount==0){
strcat(customStruct, "%f");
itemsPerPos++;
}
currentSize += 4;
if(bufferHolder == NULL)
bufferHolder = malloc(currentSize);
else
bufferHolder = realloc(bufferHolder, currentSize);
argPos = (argPos+(unsigned long)sizeof(long));
((float*)bufferHolder)[subItemsCount] = *(float*)argPos;
subItemsCount++;
}break;
case 's':{
if(itemsCount==0){
strcat(customStruct, "%s");
itemsPerPos++;
}
currentSize += 4;
if(bufferHolder == NULL)
bufferHolder = malloc(currentSize);
else
bufferHolder = realloc(bufferHolder, currentSize);
argPos = (argPos+(unsigned long)sizeof(long));
unsigned long pointer = *(unsigned long*)(argPos);
((unsigned long*)bufferHolder)[subItemsCount] = pointer;
subItemsCount++;
}break;
}
readChar = 0;
}else if(fmt[i] == '%')
readChar = 1;
else if(fmt[i] == '\0')
readding = 0;
i++;
}
itemsCount++;
};
//Guardar elementos en la array
int push(void *item){
int allocSize = 0;
switch(this->varType){
case 1:{
allocSize = sizeof(int);
}break;
case 2:{
allocSize = sizeof(float);
}break;
case 3:{
allocSize = sizeof(double);
}break;
case 4:{
allocSize = sizeof(char) * strlen((char *)item) + 1;
if(charIndex == NULL)
charIndex = (int*)malloc(sizeof(int));
else
charIndex = (int*)realloc(charIndex, (itemsCount)*sizeof(int));
}break;
default:
return 0;
break;
}
int temp_location = currentSize;
currentSize += (allocSize);
if(bufferHolder == NULL)
bufferHolder = malloc(allocSize);
else
bufferHolder = realloc(bufferHolder, currentSize);
switch(this->varType){
case 1:{
((int*)bufferHolder)[itemsCount] = *(int*)item;
}break;
case 2:{
((float*)bufferHolder)[itemsCount] = *(float*)item;
}break;
case 3:{
((double*)bufferHolder)[itemsCount] = *(double*)item;
}break;
case 4:{
for(int i = 0; i < (int)strlen((char *)item); i++)
((char *)bufferHolder)[temp_location+i] = ((char*)item)[i];
((char *)bufferHolder)[currentSize-1] = '\0';
charIndex[itemsCount] = temp_location;
}break;
default:
return 0;
break;
}
itemsCount++;
return (itemsCount-1);
};
/*
No es ni mucho menos el mejor algoritmo para ordenar, de hecho, implica una cantidad de loops extremadamente elevada,
a cuantos mas elementos, mas loops.
Su uso es muy simple:
Tenemos un elemento A en la posicion 1
Otro elemento B en la posicion 2
Si A > B, se intercambian las posiciones
Es decir, A pasa a estar en la posicion 2 i B en la 1
Se hacen loops hasta que no hace ningún cambio, lo cual significa que todos estan ordenados.
*/
void order(int orderLoop){
int loops = 0;
if(this->varType < 4){
int changes = 1;
while(changes){
changes = 0;
for(int i = 0; i < itemsCount-1; i++ && loops++){
if(orderLoop == 0){
switch(this->varType){
case 1:{
if(((int*)bufferHolder)[i] > ((int*)bufferHolder)[i+1]){
int buffer = ((int*)bufferHolder)[i+1];
((int*)bufferHolder)[i+1] = ((int*)bufferHolder)[i];
((int*)bufferHolder)[i] = buffer;
changes = 1;
}
}break;
case 2:{
if(((float*)bufferHolder)[i] > ((float*)bufferHolder)[i+1]){
float buffer = ((float*)bufferHolder)[i+1];
((float*)bufferHolder)[i+1] = ((float*)bufferHolder)[i];
((float*)bufferHolder)[i] = buffer;
changes = 1;
}
}break;
case 3:{
if(((double*)bufferHolder)[i] > ((double*)bufferHolder)[i+1]){
double buffer = ((double*)bufferHolder)[i+1];
((double*)bufferHolder)[i+1] = ((double*)bufferHolder)[i];
((double*)bufferHolder)[i] = buffer;
changes = 1;
}
}break;
}
}else{
switch(this->varType){
case 1:{
if(((int*)bufferHolder)[i] < ((int*)bufferHolder)[i+1]){
int buffer = ((int*)bufferHolder)[i+1];
((int*)bufferHolder)[i+1] = ((int*)bufferHolder)[i];
((int*)bufferHolder)[i] = buffer;
changes = 1;
}
}break;
case 2:{
if(((float*)bufferHolder)[i] < ((float*)bufferHolder)[i+1]){
float buffer = ((float*)bufferHolder)[i+1];
((float*)bufferHolder)[i+1] = ((float*)bufferHolder)[i];
((float*)bufferHolder)[i] = buffer;
changes = 1;
}
}break;
case 3:{
if(((double*)bufferHolder)[i] < ((double*)bufferHolder)[i+1]){
double buffer = ((double*)bufferHolder)[i+1];
((double*)bufferHolder)[i+1] = ((double*)bufferHolder)[i];
((double*)bufferHolder)[i] = buffer;
changes = 1;
}
}break;
}
}
}
}
}
printf("\t%d LOOPS\n", loops);
}
//Devuelve el número de elementos en la array
int count(){
return this->itemsCount;
}
//Devuelve un puntero hacia el elemento indicado
_ARRAY *ret(int pos, int item = 0){
if(pos >= itemsCount)
return this;
switch(this->varType){
case 1:{
toReturn = &((int*)bufferHolder)[pos];
}break;
case 2:{
toReturn = &((float*)bufferHolder)[pos];
}break;
case 3:{
toReturn = &((double*)bufferHolder)[pos];
}break;
case 4:{
toReturn = &((char*)bufferHolder)[charIndex[pos]];
}break;
case 5:{
int i = 2;
toReturn = &i;
this->structPos = pos;
this->structItem = item;
}break;
}
return this;
}
/* Conversiones a un tipo de variable concreta*/
int toInt(){
if(toReturn == NULL)
return 0;
int retVal;
if(this->varType < 4){
retVal = *(int*)toReturn;
}else{
if(this->varType == 4)
retVal = atoi((char*)toReturn);
else{
int switcher;
int n = 0;
for(int i = 0; n <= structItem ; i++){
if(i != 0 && i%2 != 0){
n++;
switcher = i;
}
}
switch(this->customStruct[switcher]){
case 'd':
case 'f':
case 'c':{
retVal = ((int*)bufferHolder)[(itemsPerPos*this->structPos)+structItem];
}break;
case 's':{
retVal = atoi((char*)((unsigned long*)bufferHolder)[(itemsPerPos*this->structPos)+structItem]);
}break;
}
}
}
toReturn = NULL;
return retVal;
};
float toFloat(){
return toDouble();
};
double toDouble(){
if(toReturn == NULL)
return 0;
double retVal;
if(this->varType < 4)
retVal = *(double*)toReturn;
else{
if(this->varType == 4)
retVal = atof((char*)toReturn);
else{
int switcher;
int n = 0;
for(int i = 0; n <= structItem ; i++){
if(i != 0 && i%2 != 0){
n++;
switcher = i;
}
}
switch(this->customStruct[switcher]){
case 'd':
case 'f':
case 'c':{
retVal = ((double*)bufferHolder)[(itemsPerPos*this->structPos)+structItem];
}break;
case 's':{
retVal = atof((char*)((unsigned long*)bufferHolder)[(itemsPerPos*this->structPos)+structItem]);
}break;
}
}
}
toReturn = NULL;
return retVal;
};
char *toChar(){
if(toReturn == NULL)
return 0;
char *retVal;
if(this->varType == 4)
retVal = (char*)toReturn;
else if(this->varType == 5){
int switcher;
int n = 0;
for(int i = 0; n <= structItem ; i++){
if(i != 0 && i%2 != 0){
n++;
switcher = i;
}
}
switch(this->customStruct[switcher]){
case 'd':
case 'c':{
}break;
case 'f':{
}break;
case 's':{
retVal = (char*)((unsigned long*)bufferHolder)[(itemsPerPos*this->structPos)+structItem];
}break;
}
}else{
}
toReturn = NULL;
return retVal;
};
/* End conversiones */
};
int main(int argc, char *argv[]){
printf("\n");
system("pause");
printf("\n");
printf("\tCreando array (INT)\n");
printf("\tInicializando valores\n");
//Creamos la array, usando tipo INT
_ARRAY cArray(1);
//Iniciamos las variables
int a = 5;
int b = 2;
int c = 3;
int d = 9;
int e = 8;
int f = 1;
//Debemos pasarlas como punteros, asi que, le pasamos la direccion (&)
cArray.push(&a);
cArray.push(&b);
cArray.push(&c);
cArray.push(&d);
cArray.push(&e);
cArray.push(&f);
printf("\n");
system("pause");
printf("\n");
printf("\tMostrar valores\n");
//Enseñamos en pantalla el valor de cada posicion:
//.ret(posicion) devuelve el valor como puntero
//->toInt(), asi como todas las funciones que acaban en ->to... devuelven la variable en dicho valor (hacen conversiones automáticamente)
for(int i = 0; i < cArray.count(); i++)
printf("\t%d\n", cArray.ret(i)->toInt());
printf("\n");
system("pause");
printf("\n");
printf("\tOrdenando la array\n");
//Ordenamos las variables por orden ascendente (0) o descendente (1)
cArray.order(0);
printf("\n");
system("pause");
printf("\n");
printf("\tMostrar valores ordenados\n");
//Mostramos de nuevo todas las variables, pero ordenadas
for(int i = 0; i < cArray.count(); i++)
printf("\t%d\n", cArray.ret(i)->toInt());
printf("\n");
system("pause");
printf("\n");
printf("\tCreamos la 2a array (STRUCT)\n");
printf("\tInicializando valores\n");
//La borramos
cArray.clear();
//Creamos una nueva array que servirà para guardar las estructuras
_ARRAY sArray(5);
//Creamos una estructura
struct _TEST_STRUCT{
int a;
int b;
char c[200];
char d[200];
};
//Creamos dos variables locales para la estructura
_TEST_STRUCT testStruct1 = {77, 66, "PRUEBA DE STRING 1!", "666"};
_TEST_STRUCT testStruct2 = {99, 108, "PRUEBA DE STRING 2!", "9.987657"};
//Guardamos el tamaño total de la structure
sArray.setStructSize(sizeof(_TEST_STRUCT));
//Enviamos las estructuras
sArray.pushConvertStruct("%d%d%s%s", testStruct1.a, testStruct1.b, testStruct1.c, testStruct1.d);
sArray.pushConvertStruct("%d%d%s%s", testStruct2.a, testStruct2.b, testStruct2.c, testStruct2.d);
printf("\n");
system("pause");
printf("\n");
printf("\tMostrando valores\n\n");
//Mostramos variable local 0, elemento 0
printf("\t%d\n", sArray.ret(0, 0)->toInt()); //Devolvemos tipo INT
//Mostramos variable local 0, elemento 1
printf("\t%d\n", sArray.ret(0, 1)->toInt()); //Devolvemos tipo INT
//Mostramos variable local 0, elemento 2
printf("\t%s\n", sArray.ret(0, 2)->toChar()); //Devolvemos tipo CHAR ARRAY
//Mostramos variable local 0, elemento 3
printf("\t%d\n", sArray.ret(0, 3)->toInt()); //Devolvemos tipo INT (auto-conversión: string->int)
printf("\n");
//Mostramos variable local 1, elemento 0
printf("\t%d\n", sArray.ret(1, 0)->toInt()); //Devolvemos tipo INT
//Mostramos variable local 1, elemento 1
printf("\t%d\n", sArray.ret(1, 1)->toInt()); //Devolvemos tipo INT
//Mostramos variable local 1, elemento 2
printf("\t%s\n", sArray.ret(1, 2)->toChar()); //Devolvemos tipo CHAR ARRAY
//Mostramos variable local 1, elemento 3
printf("\t%f\n", sArray.ret(1, 3)->toFloat()); //Devolvemos tipo FLOAT (auto-conversión: string->float)
printf("\n");
system("pause");
return 0;
}
Nota1: Como bien a recalcado Shantotto, que parece que no me acabé de explicar bien, lo siento, este código es puramente educativo, su finalidad práctica es nula, a no ser que se optimice (que prácticamente implica cambiar todo el código), puesto que la función realloc(), permitidme usar las palabras de el mismo Shantotto, fragmenta mucho la RAM y básicamente, corrompe el heap. En otras palabras, no conviene abusar de la función realloc.
Nota2: Falta añadir conversiones de números (en general) a string, pero no tiene mucho secreto. Se puede crear un char* e ir añadiendole los caracteres mediante strcat, o sino, mucho más limpio y efectivo, usar realloc() (funcion parecida a malloc, pero que en vez de borrar todo lo existente, añade mas memoria a una memoria ya previa mas pequeña) y indirecciones con * para guardar los valores.
Faltaba algo más de lo cual no me acuerdo xd
En 1 mes o así me pondré a programar lo que pueda (al principio poca cosa) y luego iré subiendo el nivel si puedo. Os iré leyendo mientras. 
![[boing]](/images/smilies/nuevos/pelota_ani1.gif "pelota")
![[oki]](/images/smilies/net_thumbsup.gif "Ok!")
![[tadoramo]](/images/smilies/adora.gif "Adorando")
Pensé en el uso de strtok y trocear la cadena en base a los espacios para obtener cada argumento por separado en un array por ejemplo. El problema es que los argumentos también necesitan información, como por ejemplo "ping -c 5 www.google.es". Conclusión, si no resuelvo esto ya me puedo ir olvidando... ![[mamaaaaa]](/images/smilies/nuevos/triste_ani4.gif "llorica")
) pero lo que pregunto lo busco antes y al no encontrarlo recurro a vosotros... Al usar la función chdir() y una dirección con espacios la ruta no cambia. Este es el código que estoy probando sin resultado: