Mensajes

MODIFICADO:


ATOI

Código (cpp) [Seleccionar] Expandir


/********************************************************************************************************

// By 85
// boyscout_arg@hotmail.com
// etalking.com.ar
// David Riedel
// 2013

*********************************************************************************************************/

#pragma warning (disable:4305)
#pragma warning (disable:4309)
#pragma warning (disable:4244)
#pragma warning (disable:4018)
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>

/////

// Sin necesidad de llamadas innecesarias a funciones de CTYPE, MATH, STRING, etc
// Sin necesidad de Tablas, solo un array con los números enteros que tampoco es necesario
// pero no hace la gran diferencia ;-D

//////////////////////////////////////////////////

//Se requiere pasar una cadena terminada en CERO!.
//Si no se le pasa una cadena terminada en CERO, la función va a buscar el
//primer 0 que encuentre y puede terminar en una sección de memoria contigua
//que no pertenece a la cadena pasada como parámetro.
int mi_atoi(const char* str)//Respetar el tipo de parámetro (Sólo cadenas)
{
int len, ocurrencias =0, sig=0;
for(len=0; str[len]; len++);
for(int a=0; a<len;a++) if((str[a]>=48&&str[a]<=57)) ocurrencias++;
if(ocurrencias==0) return 0;
if((sig=str[0]=='+')||(sig=str[0]=='-')) ocurrencias+=1;
if(ocurrencias<len) return 0;//Casos "11f" son 0
if(len==1) return str[0]-'0';
int ac=0, v1, cifras = len,m = 1;
for(int x=0;x<((cifras-1)-sig);x++) m*=10;
for(int i=sig;i<cifras;i++){//Factoriza y acumula
v1=str[i]-'0';
v1*=m;
ac=(v1==0?ac+0:ac+v1);
m/=10;
}
if(str[0]=='-') ac*=-1;
return ac;
}

////////////////////

int main(){

// char str = 'B';
// int entero = mi_atoi(&str);

// char* str = "asdasd\0";
// int entero = mi_atoi(str);

// char* str = "8a3\0";
// int entero = mi_atoi(str);

// char* str = "83312321\0";
// int entero = mi_atoi(str);

// char* str = "000000099\0";
// int entero = mi_atoi(str);

// char* str = "9\0";
// int entero = mi_atoi(str);

// char* str = "20\0";
// int entero = mi_atoi(str);

// char* str = "500\0";
// int entero = mi_atoi(str);

// char* str = "+500\0";
// int entero = mi_atoi(str);

// char* str = "0500\0";
// int entero = mi_atoi(str);

// char* str = "0\0";
// int entero = mi_atoi(str);

// char* str = "10f\0";
// int entero = mi_atoi(str);

// char* str = "01ff\0";
// int entero = mi_atoi(str);

// char* str = "0f\0";
// int entero = mi_atoi(str);

// char* str = "+12\0";
// int entero = mi_atoi(str);

// char* str = "+12\0";
// int entero = mi_atoi(str);

// char* str = "03232\0";
// int entero = mi_atoi(str);

// printf("%d", entero);


printf("%d\n",mi_atoi("-110"));
printf("%d\n",mi_atoi("-10"));
printf("%d\n",mi_atoi("0"));
printf("%d\n",mi_atoi("1"));
printf("%d\n",mi_atoi("-1"));
printf("%d\n",mi_atoi("-11"));
printf("%d\n",mi_atoi("-2"));
printf("%d\n",mi_atoi("-200"));
printf("%d\n",mi_atoi("-220"));
printf("%d\n",mi_atoi("+0"));
printf("%d\n",mi_atoi("-0"));
printf("%d\n",mi_atoi("+1"));
printf("%d\n",mi_atoi("+33"));
printf("%d\n",mi_atoi("-330"));
printf("%d\n",mi_atoi("-3000"));
// printf("%d\n",mi_atoi("-1"));
// printf("%d\n",mi_atoi("-200"));
// printf("%d\n",mi_atoi("-220"));
printf("%d\n",mi_atoi("+12"));

printf("\n");
system("pause");
return 0;
}


ITOA

Código (cpp) [Seleccionar] Expandir


/********************************************************************************************************

// By 85
// boyscout_arg@hotmail.com
// etalking.com.ar
// David Riedel
// 2013

*********************************************************************************************************/

#pragma warning (disable:4305)
#pragma warning (disable:4309)
#pragma warning (disable:4244)
#pragma warning (disable:4018)
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>

/////

// Sin necesidad de llamadas innecesarias a funciones de CTYPE, MATH, STRING, etc
// Sin necesidad de Tablas, sólo un array con los números enteros que tampoco es necesario
// pero no hace la gran diferencia ;-D

//////////////////////////////////////////////////

char* mi_itoa(int num, char* str)
{
int sig = -1;
if(num<0){
num*=-1;
if(num<10){
str[0]='-'; str[1]='0'+num; str[2]=0; return str;
} else {
sig=1;
}
}
else if(num==0){
str[0]='0'; str[1]=0; return str;
} else {
if(num<10){
str[0]='0'+num; str[1]=0; return str;
} else {
sig=0;
}
}
if(sig!=-1){
int copia= num, m = 1, cifras = 1;
for(;copia>=10;copia/=10) cifras++;
for(int x=0;x<(cifras-1);x++) m*=10;
float v1=num;
int v2=0, v3=num;
if(sig) str[0]='-';
for(int i=0; i<cifras; i++){//Descompone en factores
v1/=m;
v2=(int)v1*m;
v3-=v2;
m/=10;
str[i+sig]=48+(int)v1;
v1=v3;
}
str[i+sig]=0;//Si str está a 0 no es necesario..
}
return str;
}

///////////////////

int main(){


char str[256];

// mi_itoa(321312,str);
// printf(str);

// itoa(02321,str,10);
// printf(str);

// mi_itoa(02321,str);
// printf(str);

// mi_itoa(-12321,str);
// printf(str);

// itoa(-012321,str,10);
// printf(str);

// mi_itoa(-012321,str,10);
// printf(str);

// mi_itoa(555,str);
// printf(str);

// mi_itoa(0,str);
// printf(str);

// mi_itoa(1,str);
// printf(str);

// mi_itoa(500,str);
// printf(str);

printf(mi_itoa(+321312,str));printf("\n");
printf(mi_itoa(-321312,str));printf("\n");
printf(mi_itoa(321312,str));printf("\n");
printf(mi_itoa(+0,str));printf("\n");
printf(mi_itoa(0,str));printf("\n");
printf(mi_itoa(-0,str));printf("\n");
printf(mi_itoa(+1,str));printf("\n");
printf(mi_itoa(1,str));printf("\n");
printf(mi_itoa(-1,str));printf("\n");
printf(mi_itoa(10,str));printf("\n");
printf(mi_itoa(+10,str));printf("\n");
printf(mi_itoa(-10,str));printf("\n");
printf(mi_itoa(-110,str));printf("\n");
printf(mi_itoa(-100,str));printf("\n");

printf(mi_itoa(-5000,str));printf("\n");
printf(mi_itoa(-55555,str));printf("\n");
printf(mi_itoa(550,str));printf("\n");
printf(mi_itoa(500,str));printf("\n");
printf(mi_itoa(+330,str));printf("\n");

printf(mi_itoa(-000,str));printf("\n");
printf(mi_itoa(+000,str));printf("\n");
// printf(mi_itoa(+00009,str));printf("\n");
printf(mi_itoa(+109,str));printf("\n");
printf(mi_itoa(-109,str));printf("\n");
// printf(mi_itoa(-09,str));printf("\n");
// printf(mi_itoa(+09,str));printf("\n");
printf(mi_itoa(-999,str));printf("\n");
// printf(mi_itoa(-00000999,str));printf("\n");

printf("\n");
system("pause");
return 0;
}

/////



Hola, esta clase fecha es de un curso que había hecho en mi facultad. La clase no fue escrita por mi, yo sólo agregué las funciones a lo último.
Pero me doy cuenta de la utilidad que puede tener para gente iniciada que tiene esta clase de problemas que sus profesores le piden ejercicios con fechas. Les puede servir.

Código [Seleccionar] Expandir



//

//Puede utilizarse para fechas desde el 01/01/1900

class Fecha
{
private:
    int dia;
    int mes;
    int año;
//  bool esbisiesto(int);
    void NumeroSerieaFecha(int);
public:
bool esbisiesto(int);
    Fecha(int d=0,int m=0,int a=0);
    int getDia(){return dia;}
    int getMes(){return mes;}
    int getAnio(){return año;}
    void setDia(int d){dia=d;}
    void setMes(int m){mes=m;};
    void setAnio(int a){año=a;}
    void MostrarFecha();
    void MostrarFechaTexto();
    int NumeroSerie();
    bool operator >(Fecha &);
    bool operator ==(Fecha &);
    Fecha operator+(int);
    int operator -(Fecha &);
    void operator +=(int);
    int operator==(char *);
    friend istream & operator>>(istream &, Fecha &);
    friend ostream & operator<<(ostream &, Fecha &);
    int cantDiasMes();
    int cantDiasHabilesMes();
    int cantAniosHastaHoy();
bool EsSuperiorAFechaActual(Fecha fx);
int FechaEntreDosFechas(Fecha inicio_de_promocion, Fecha fin_de_promocion, Fecha fecha_de_compra );
unsigned int CalcularEdad(Fecha birthdate);
};

Fecha::Fecha(int d,int m,int a)
{//El constructor asigna los valores recibidos, si le son pasados como parámetros

if(d!=0)
{
       dia=d;mes=m;año=a;//¿Qué modificación habría que hacerle al constructor para
}                   // garantizar que no se asignen valores absurdos? Ej.:65/65/-12
    else  //si no recibe valores asigna por defecto la fecha actual
{
    time_t tiempo;
    struct tm *tmPtr;
    tiempo = time(NULL);
    tmPtr = localtime(&tiempo);
    año=tmPtr->tm_year+1900;
    mes=tmPtr->tm_mon+1;
    dia=tmPtr->tm_mday;
}
}

//Devuelve true si el año recibido es bisiesto.
bool Fecha::esbisiesto(int a)
{
bool bisiesto=false;
    if(a%4==0)
       bisiesto=true;
    if((a%100==0) && (a%400!=0))
        bisiesto=false;
return bisiesto;
}

//Muestra la fecha en formato número. Ej.:  15/10/2008
void Fecha::MostrarFecha()
{
cout<<dia<<"/"<<mes<<"/"<<año<<endl;
}//¿Qué modificación habría que hacer para que siempre muestre DD/MM/AAAA?


//Devuelve 1 si la fecha coincide con una cadena que representa un día de la semana
int Fecha::operator==(char *diaSemana)
{
int cantdias=NumeroSerie()-1;//cantidad de días transcurridos desde 01/01/1900
    //El 01/01/1900 fue Lunes
    int numerodia=cantdias%7;

    char mdia[7][10];
    strcpy(mdia[0],"Lunes");
    strcpy(mdia[1],"Martes");
    strcpy(mdia[2],"Miercoles");
    strcpy(mdia[3],"Jueves");
    strcpy(mdia[4],"Viernes");
    strcpy(mdia[5],"Sábado");
    strcpy(mdia[6],"Domingo");
    if(strcmp(mdia[numerodia],diaSemana)==0)
        return 1;
    return 0;
}

//Muestra la fecha indicando en texto el día y el mes.Ej.: Lunes 1 de enero de 1900
void Fecha::MostrarFechaTexto()
{
char mmes[12][11];
    strcpy(mmes[0],"Enero");
    strcpy(mmes[1],"Febrero");
    strcpy(mmes[2],"Marzo");
    strcpy(mmes[3],"Abril");
    strcpy(mmes[4],"Mayo");
    strcpy(mmes[5],"Junio");
    strcpy(mmes[6],"Julio");
    strcpy(mmes[7],"Agosto");
    strcpy(mmes[8],"Septiembre");
    strcpy(mmes[9],"OCtubre");
    strcpy(mmes[10],"Noviembre");
    strcpy(mmes[11],"Diciembre");

    int cantdias=NumeroSerie()-1;//cantidad de días transcurridos desde 01/01/1900
    //El 01/01/1900 fue Lunes
    int numerodia=cantdias%7;

    char mdia[7][10];
    strcpy(mdia[0],"Lunes");
    strcpy(mdia[1],"Martes");
    strcpy(mdia[2],"Miercoles");
    strcpy(mdia[3],"Jueves");
    strcpy(mdia[4],"Viernes");
    strcpy(mdia[5],"Sábado");
    strcpy(mdia[6],"Domingo");

    cout<<endl<<mdia[numerodia]<<" "<<dia<<" de "<<mmes[mes-1]<<" de "<<año<<endl;
}

//Devuelve la cantidad de días transcurridos desde el 01/01/1900
int Fecha::NumeroSerie()
{
int cont=0,i;
    for(i=1900;i<año;i++) if(esbisiesto(i)) cont++;
    int vmes[]={31,28,31,30,31,30,31,31,30,31,30,31},suma=0;
    if(esbisiesto(año)) vmes[1]=29;
    for(i=0;i<mes-1;i++)  suma+=vmes[i];
    int cantdias=(año-1900)*365+cont+suma+dia;
    return cantdias;
}

//Sobrecargas
bool Fecha::operator>(Fecha &obj)
{
if(NumeroSerie()>obj.NumeroSerie())
return true;
    return false;
}

bool Fecha::operator==(Fecha &obj)
{
if(NumeroSerie()==obj.NumeroSerie()) return true;
    //Otra posibilidad
    //if(dia==obj.dia && mes==obj.mes && año==obj.año)
    //  return true;
    return false;
}

void Fecha::NumeroSerieaFecha(int ns)
{
int suma=0, dia_adicional, suma_ant;
    int anio_real=1900;
    while(ns>suma)
    {
    dia_adicional=(esbisiesto(anio_real)?1:0);
    suma_ant=suma;
    suma+=365+dia_adicional;
    anio_real++;
    }
    año=anio_real-1;
    //Cantidad de días pasados desde año
    int dias_anio_actual=ns-suma_ant,i=0;
    int vmes[]={31,28,31,30,31,30,31,31,30,31,30,31};
    if(esbisiesto(año)) vmes[1]=29;
    suma=0;
    while(dias_anio_actual>suma) suma+=vmes[i++];
    mes=i;
    dia=dias_anio_actual-(suma-vmes[i-1]);
}

void Fecha::operator +=(int masdias)
{
int  ns=NumeroSerie()+masdias;
    NumeroSerieaFecha(ns);
}

istream & operator>>(istream &entra, Fecha &f)
{
cout<<"Ingrese el dia: ";
    entra>>f.dia;
    cout<<"Ingrese el mes: ";
    entra>>f.mes;
    cout<<"Ingrese el año: ";
    entra>>f.año;
    return entra;
}

ostream & operator<<(ostream &sale, Fecha &f)
{
cout<<"Dia: ";
    sale<<f.dia<<endl;
    cout<<"Mes: ";
    sale<<f.mes<<endl;
    cout<<"Año: ";
    sale<<f.año<<endl;
    return sale;
}

Fecha Fecha::operator+(int masdias)
{
Fecha aux;
    int  ns=NumeroSerie()+masdias;
    aux.NumeroSerieaFecha(ns);
    return aux;
}

int Fecha::operator -(Fecha &obj)
{
return NumeroSerie()-obj.NumeroSerie();
}

int Fecha::cantDiasMes()
{
int vmes[]={31,28,31,30,31,30,31,31,30,31,30,31};
    if(esbisiesto(año)) vmes[1]=29;
    return vmes[mes-1];
}

// Devuelve la cantidad de días hábiles del mes correspondiente a la fecha
// No tiene en cuenta si en el mes hay o no feriados
// Una posibilidad es que se identifique en una matriz los días feriados del año
// y se compare cada día con esa matriz
int Fecha::cantDiasHabilesMes()
{
int totDias=cantDiasMes();
    int dia, cant=0;
    Fecha aux=*this;
    for(int i=1;i<=totDias;i++)
    {
         dia=(aux.NumeroSerie()-1)%7;
         if(dia<5) cant++;
         aux+=1;
    }
    return cant;
}

//Devuelve la cantidad de años entre una fecha y el día actual
int Fecha::cantAniosHastaHoy()
{
Fecha aux; //por usar un constructor por defecto tiene la fecha de hoy;
    int cant=aux.año-año;
    if(mes>aux.mes) return cant-1;
    if(mes==aux.mes && dia>aux.dia) return cant-1;
    return cant;
}

////////////////////////////////////////////////////////////////////////////////////

bool Fecha::EsSuperiorAFechaActual(Fecha fx){

SYSTEMTIME time;
::GetLocalTime(&time);
//
//la promocion debe ser superior a la fecha actual..
if( fx.getAnio()>time.wYear ||
(fx.getAnio()==time.wYear && fx.getMes()>time.wMonth) ||
(fx.getAnio()==time.wYear && fx.getMes()==time.wMonth && fx.getDia()>time.wDay))
{
return true;
}
return false;
}

/////////////////////////////////////////////////////////////////////////////////////////////

int Fecha::FechaEntreDosFechas(Fecha inicio_de_promocion, Fecha fin_de_promocion, Fecha fecha_de_compra ){


//---------------
// PARTE1

if(fecha_de_compra.getAnio() < inicio_de_promocion.getAnio() )return 0;

if(fecha_de_compra.getAnio() == inicio_de_promocion.getAnio() ){
if(fecha_de_compra.getMes() < inicio_de_promocion.getMes())return 0;
}

if(fecha_de_compra.getAnio() == inicio_de_promocion.getAnio() ){
if(fecha_de_compra.getMes() == inicio_de_promocion.getMes())
if(fecha_de_compra.getDia() < inicio_de_promocion.getDia())return 0;
}

//------------------
// PARTE2

if(fecha_de_compra.getAnio() > fin_de_promocion.getAnio() )return 0;

if(fecha_de_compra.getAnio() == fin_de_promocion.getAnio() ){
if(fecha_de_compra.getMes() > fin_de_promocion.getMes())return 0;
}

if(fecha_de_compra.getAnio() == fin_de_promocion.getAnio() ){
if(fecha_de_compra.getMes() == fin_de_promocion.getMes())
if(fecha_de_compra.getDia() > fin_de_promocion.getDia())return 0;
}

//-----------

return 1;
}

///////////////////////

/*
unsigned int Fecha::CalcularEdad(Fecha birthdate)
{
int AnioActual, AA, MesActual, MM, DiaActual, DD;
int año, Mes, Dia;

int MonthDays[2][12]  = {

{31, 28, 30, 31, 30, 31, 31, 31, 30, 31, 30, 31},
            {31, 29, 30, 31, 30, 31, 31, 31, 30, 31, 30, 31}
};

SYSTEMTIME time;
GetLocalTime(&time);
AA=birthdate.getAnio();
MM=birthdate.getMes();
DD=birthdate.getDia();
AnioActual=time.wYear;
MesActual=time.wMonth;
DiaActual=time.wDay;
año = AA-AnioActual;
if( MesActual <= MM )
{
Mes = MM - MesActual;
}
else
{
Mes = MM+12-MesActual;
año = año -1;
}
if( DiaActual <= DD )
{
Dia = DD - DiaActual;
}
else
{
Dia=DD+MonthDays[birthdate.esbisiesto(AA)][MM-1]-DiaActual;
Mes = Mes -1;
}
if( Mes < 0 )
{
año = año - 1;
Mes = 12 + Mes;
}
unsigned int Arreglo=año*(-1);
//Result = Format('Años: %.0f, Meses: %.0f, Dias: %.0f', [año, Mes, Dia]);
return Arreglo;
}*/

unsigned int Fecha::CalcularEdad(Fecha birthdate)
{
// Initialize variables
int ReturnAge = 0;
SYSTEMTIME  stLocal;

GetLocalTime( &stLocal ); // Get local time

ReturnAge = stLocal.wYear - birthdate.getAnio();
if ( stLocal.wMonth <= birthdate.getMes() )
{
if ( stLocal.wMonth == birthdate.getMes() )
{
if ( stLocal.wDay <= birthdate.getDia() )
ReturnAge--;
}
else
ReturnAge--;
}

return ReturnAge;
}


amigo tu código estaba algo desordenado porque ni compilaba, si tu problema era que la sumatoria de 1 entonces así está bien

Código [Seleccionar] Expandir


#include<iostream>
#include<string.h>
using namespace std;

int main()
{
float //GASSEP[11],
//GASST[11],
LIQST[11],
M=0,
V=0,
c,
//PMA[11],
//SGC7,
//VM[11],
//D,
//SG,
//API,
Densidades[11]={50.032f,51.044f,19.98f,29.34f,31.62f,35.11f,36.42f,38.96f,39.36f,41.40f,53.11f};

unsigned int i=0,j=0,k=0;
short PM[11]={34,44,16,30,44,58,58,72,72,86};

char comp[11][15]={"CO2","H2S","C1","C2","C3","iC4","nC4","iC5","nC5","C6","C7+"};

cout<<"DATOS DEL STOK TANK\nComposicion liqido:\n";

do{

for(i=0;i<=10;i++)
{
cout<< "comp: "<< comp[i]<<"\t";
fflush(stdin);
cin>>LIQST[i];
fflush(stdin);

while(LIQST[i]>=1)
{
system ("cls");
cout<<"DATOS DEL STOK TANK\nComposicion liqido:\n";
cout<< "comp: "<< comp[i]<<"\t";
fflush(stdin);
cin>>LIQST[i];
fflush(stdin);
}

//while(LIQST[i]>1);
}

//system ("cls");

c=0;
for(j=0;j<=10;j++)//sumatoria
c=c+LIQST[j];

cout<<"\n";
if(c==1)break;

system ("cls");
printf("La sumatoria no ha dado 0 !\n");

} while(1);//while(c!=1);

printf("Resultado: %f\n", c);
system ("pause");
return 0;
}


si te ayuda de algo
http://codigomaldito.blogspot.com.ar/2004/11/sobrecarga-de-operadores-en-c.html

si necesitás improvisar un contador usa timeGetTime que es para windows.

sino Clock que sirve para linux y windows

y hay otras muchas funciones con las cuales podés construir un contador

[switch]

cuando se trata de saber si es positivo o no, te conviene evaluar el estado booleano de la variable:

Código [Seleccionar] Expandir

if ( variable ){// si es distinto de cero
}


sin necesidad del operador de asignación = , o el de comparación ==.
osea algunos se confunden con este operador y asignan a donde deben comparar.

si variable es por ejemplo un entero y puede tomar muchos valores como resultado, entonces vas a necesitar evaluar esa variable con un switch , que es una
evaluación mucho más rápida que usar muchos if + else if

claro, pero te digo algo no es que yo hubiera elegido esa palabra sino que en el texto original dice así..
http://www.lix.polytechnique.fr/~liberti/public/computing/prog/c/C/CONCEPT/bitwise.html

AND & will copy a bit to the result if it exists in both operands.

osea es como decir 'va a copiar' o 'copiará', o en presente 'copia'

pero me parece que está bien porque no se refiere en sí a la operación AND, sino a lo que ocurre con esas 3 variables A, B y C, desde el punto de vista del código.
Es decir, lo que resulte de comparar A y B 'se copia' al resultado C. Se podía haber usado otra expresión, 'se copia', 'se pasa', 'se translada', 'da como resultado', en fin, porque se refiere más que nada al resultado y no a la operación.
Igualmente esto no es ni siquiera un tutorial, y estaría bueno dar más ejemplos del uso de estos operadores. hay comentarios de gente que dice que no son de mucha utilidad, pero no me parece que sea así

[AND - OR - XOR ( requieren dos operandos y hacen comparaciones de bits.)=================================================]

Hola, esto viene a ser una demostración con ejemplos más que un tutorial.
Básicamente vamos a hacer una revisión de todos los operadores de bits del lenguaje C y mostrar su funcionamiento.

&        AND
&=      AND Asignativo
|         OR
|=       OR  Asignativo
^        XOR
^=      XOR Asignativo
~        Complemento de Uno
<<      Desplazamiento Izquierdo
<<=    Desplazamiento Izquierdo Asignativo
>>      Desplazamiento Derecho
>>=    Desplazamiento Derecho Asignativo

Para mostrar su funcionamiento, pongo  ejemplos de este enlace:

http://www.lix.polytechnique.fr/~liberti/public/computing/prog/c/C/CONCEPT/bitwise.html

Sólo que traduje lo que estaba en otro idioma e hice una combinación de todos los ejemplos como para que quede algo entendible.


AND - OR - XOR ( requieren dos operandos y hacen comparaciones de bits.)
=================================================

AND & copia un bit al resultado si existe en los dos operandos.
   

Código [Seleccionar] Expandir

unsigned int a = 60; /* 60 = 0011 1100 */
unsigned int b = 13; /* 13 = 0000 1101 */
unsigned int c = 0;
c = a & b;              /* 12 = 0000 1100 */
   

OR | copia un bit al resultado si existe en algún operando.

Código [Seleccionar] Expandir

unsigned int a = 60; /* 60 = 0011 1100 */
unsigned int b = 13; /* 13 = 0000 1101 */
unsigned int c = 0;  
c = a | b;              /* 61 = 0011 1101 */


XOR ^ copia un bit al resultado si existe en un operando y no en otro.

Código [Seleccionar] Expandir

unsigned int a = 60; /* 60 = 0011 1100 */
unsigned int b = 13; /* 13 = 0000 1101 */
unsigned int c = 0;
c = a ^ b;              /* 49 = 0011 0001 */




Complemento de uno ( es unario (require un operando))
======================================

NOT ~ tiene el efecto de invertir bits.

Código [Seleccionar] Expandir

unsigned int Valor=4;          /*   4 = 0000 0100 */
Valor = ~ Valor;               /* 251 = 1111 1011 */




Cambio de bits
============

Los siguientes operadores se usan para desplazar bits a la derecha o izquierda.

Código [Seleccionar] Expandir

<< ; >> ; <<= ; >>=

El valor del operando izquierdo es movido a la derecha o izquierda por el número de bits especificado
en el operando derecho.
Por ejemplo:

Código [Seleccionar] Expandir

unsigned int Valor=4;                   /*  4 = 0000 0100 */
unsigned int Desplazamiento=2;
Valor = Valor << Desplazamiento;        /* 16 = 0001 0000 */
Valor <<= Desplazamiento;               /* 64 = 0100 0000 */
printf("%d\n", Valor);                  /* Muestra 64     */


Usualmente, El bit vacío resultante es asignado como cero (padding).

Nota: Siempre use variables 'unsigned' con estos operadores para eludir resultados impredecibles.

Los usos de enumeran a continuación pero los ejemplos se los dejo para que los busquen en la red, o si los usuarios del foro de C/C++ se animan a poner sus ejemplos personales del uso de estos operadores XD

Usos para Operadores de Bits:
=====================
- Extraer y borrar valores
- Insertar y combinar valores
- Intercambiar variables
- Reemplazar operaciones aritméticas

De todas formas dejo para descargar un proyecto que es parte de esta demostración,  y dentro de la carpeta que tiene, hay otra con ejemplos tomados de la web original.

Proyecto MSVC++ 6.0

de nada, me alegro que te sirva

[Punto de entrada del programa]

Hola, esto es parte de un test que había hecho hace un tiempo, y a decir verdad la idea me la dió un usuario de este foro (Karman), aunque esto estaba hecho hace mucho tiempo atrás en otros sitios.

Esta demostración es completamente por medio de código, pero en la realidad lo que ocurre es que nosotros necesitamos saber por ejemplo, la dirección de una struct llamada 'Player' de un juego X. Osea que tendremos que usar algún depurador y obtenerla manualmente. Este tutorial no es acerca de eso, sino que se muestra como se puede obtener la dirección de una struct en memoria, de forma dinámica; sólo pasándole ciertos parámetros necesarios para que el programa pueda hallarla en memoria.

A continuación dejo el código, se trata de saber manejar punteros como para ir navegando la posición de la struct. El código tiene algunos comentarios, me da la impresión que no necesita mucha explicación.

Código [Seleccionar] Expandir


//////////////////////////////////////////////////////////////////

//
// UTN FRGP
// 2012
// david_BS
// EMAIL: david_bs@live.com
//

//////////////////////////////////////////////////

#include <windows.h>
#include <stdio.h>

typedef int (*pfnUserMsgHook)(const char *pszName, int iSize, void *pbuf);

struct paquete {

int index;
double asd;
double rr;
float gg;
};

struct paquete pak0_s;
struct paquete* pak1_s;
static int callmuestra(char *szMsgName, pfnUserMsgHook pfn);
static int hookmuestra(char *szMsgName, pfnUserMsgHook pfn);



Punto de entrada del programa

Código [Seleccionar] Expandir


int main(){

BYTE* address=(BYTE*)&hookmuestra;// ustedes sabrán porque es BYTE* (para luego incrementar de a 1 byte :p)
DWORD* address2=(DWORD*)&callmuestra;// DWORD incrementa de a 4 bytes

printf("hookmuestra: %x\n", address);//401040
printf("callmuestra: %x\n", address2);//401030

struct paquete* ptr = (paquete*)  (
*(DWORD*)
(
(
(address+=10)

+

*(DWORD*)(address+1)

+

5
)
+
2
)
 );

   printf("La direccion de la struct es: %x\n", ptr);

// Logueamiento parte por parte
// printf("address %x\n", address);
//printf("address %x\n", address+=10);//sólo sino se usa ptr que ya incrementa 10
// printf("address %x\n", *(DWORD*)(address+1));
// printf("address %x\n", address + *(DWORD*)(address+1) +5);
// printf("address %x\n", *(DWORD*)((address + *(DWORD*)(address+1) +5) +2 ));

system("pause");
return 0;
}


La función 'callmuestra' contiene la referencia a la struct

Código [Seleccionar] Expandir


static int callmuestra(char *szMsgName, pfnUserMsgHook pfn){

pak0_s.index = 5;

return 0;
}

static int hookmuestra(char *szMsgName, pfnUserMsgHook pfn){


callmuestra(szMsgName,pfn);

return 0;
}


Con un debugger o depurador, pueden acceder a la memoria de este programa y observar el código de cada función, y de la localización de la struct.
Pueden usar el depurador que viene con el compilador, en mi caso uso el depurador del MSVC++ 6.0 , o el de codeblocks.

también dejé algunos comentarios en el ASM de los dumps

Código [Seleccionar] Expandir


//callmuestra
00401030   C705 10A94000 05>MOV DWORD PTR DS:[40A910],5 //+2 (direccion de struct)
0040103A   33C0             XOR EAX,EAX
0040103C   C3               RETN


Código [Seleccionar] Expandir


//hookmuestra
00401040   8B4424 08        MOV EAX,DWORD PTR SS:[ESP+8]
00401044   8B4C24 04        MOV ECX,DWORD PTR SS:[ESP+4]
00401048   50               PUSH EAX
00401049   51               PUSH ECX //+10
0040104A   E8 E1FFFFFF      CALL ptr_to_s.00401030 //+1=E8 (+5 = E8+offset)
0040104F   83C4 08          ADD ESP,8
00401052   33C0             XOR EAX,EAX
00401054   C3               RETN


Código [Seleccionar] Expandir


0040A940   0000             ADD BYTE PTR DS:[EAX],AL
0040A942   0000             ADD BYTE PTR DS:[EAX],AL
0040A944   0000             ADD BYTE PTR DS:[EAX],AL
0040A946   0000             ADD BYTE PTR DS:[EAX],AL
0040A948   0000             ADD BYTE PTR DS:[EAX],AL
0040A94A   0000             ADD BYTE PTR DS:[EAX],AL
0040A94C   0000             ADD BYTE PTR DS:[EAX],AL
0040A94E   0000             ADD BYTE PTR DS:[EAX],AL
0040A950   0000             ADD BYTE PTR DS:[EAX],AL
0040A952   0000             ADD BYTE PTR DS:[EAX],AL
0040A954   0000             ADD BYTE PTR DS:[EAX],AL
0040A956   0000             ADD BYTE PTR DS:[EAX],AL
0040A958   0000             ADD BYTE PTR DS:[EAX],AL
0040A95A   0000             ADD BYTE PTR DS:[EAX],AL
0040A95C   0000             ADD BYTE PTR DS:[EAX],AL
0040A95E   0000             ADD BYTE PTR DS:[EAX],AL
0040A960   0000             ADD BYTE PTR DS:[EAX],AL
0040A962   0000             ADD BYTE PTR DS:[EAX],AL
0040A964   0000             ADD BYTE PTR DS:[EAX],AL
0040A966   0000             ADD BYTE PTR DS:[EAX],AL
0040A968   0000             ADD BYTE PTR DS:[EAX],AL
0040A96A   0000             ADD BYTE PTR DS:[EAX],AL
0040A96C   0000             ADD BYTE PTR DS:[EAX],AL
0040A96E   0000             ADD BYTE PTR DS:[EAX],AL
0040A970   0000             ADD BYTE PTR DS:[EAX],AL
0040A972   0000             ADD BYTE PTR DS:[EAX],AL
0040A974   0000             ADD BYTE PTR DS:[EAX],AL
0040A976   0000             ADD BYTE PTR DS:[EAX],AL
0040A978   0000             ADD BYTE PTR DS:[EAX],AL
0040A97A   0000             ADD BYTE PTR DS:[EAX],AL
0040A97C   280A             SUB BYTE PTR DS:[EDX],CL
0040A97E   0000             ADD BYTE PTR DS:[EAX],AL
0040A980   0105 00000500    ADD DWORD PTR DS:[50000],EAX


Proyecto MSVC++ 6.0

Que sigan bien ;-D