Mensajes

.
yo usaría los recursos por medio de la dll:

BeginUpdateResource
UpdateResource
EndUpdateResource
... etc.
Ejemplo

una vez abierto el recurso puedes usar:
LoadString
LoadBitmap
P.D.: ¿solo unos pocos usuarios pueden subir archivos así como tu o como esta la cosa?

Dulces Lunas!¡.

.
Estoy probando las plantillas que trae la STL y me viene a la mente usar la clase reverse_iterator.

La cuestión es como la uso, hasta ahora solo hice una cutre pero sin usar la plantilla reverse_iterator?

Código (c++) [Seleccionar] Expandir



#ifndef cbyte_H
#define cbyte_H

#include <string.h>
#include <iterator>

using namespace std;

#ifndef _BYTE_
#define _BYTE_
typedef unsigned char   byte;
#endif  //#ifndef _BYTE_

class bytesiterator : public iterator<input_iterator_tag, byte> {
   private:
       const byte            *__p_vbyte;
   public:
       bytesiterator ( const byte *__pv_byte ) : __p_vbyte(__pv_byte) {  };
       virtual ~bytesiterator() {};
       bytesiterator   &operator++() {++this->__p_vbyte;return *this;}
       bytesiterator   operator++(int) {bytesiterator tmp(*this); operator++(); return tmp;}
       bytesiterator   &operator--() {--this->__p_vbyte;return *this;}
       bytesiterator   operator--(int) {bytesiterator tmp(*this); operator--(); return tmp;}
       bool operator   ==(const bytesiterator &__r_cbyte) {return this->__p_vbyte==__r_cbyte.__p_vbyte;}
       bool operator   !=(const bytesiterator &__r_cbyte) {return this->__p_vbyte!=__r_cbyte.__p_vbyte;}
       int operator    *() {return *this->__p_vbyte;}
};

class bytesiteratorreverse : public iterator<input_iterator_tag, byte> {
   private:
       const byte            *__p_vbyte;
   public:
       bytesiteratorreverse ( const byte *__pv_byte ) : __p_vbyte(__pv_byte) {  };
       virtual ~bytesiteratorreverse() {};
       bytesiteratorreverse   &operator++() {--this->__p_vbyte;return *this;}
       bytesiteratorreverse   operator++(int) {bytesiteratorreverse tmp(*this); operator++(); return tmp;}

       bytesiteratorreverse   &operator--() {++this->__p_vbyte;return *this;}
       bytesiteratorreverse   operator--(int) {bytesiteratorreverse tmp(*this); operator--(); return tmp;}

       bool operator   ==(const bytesiteratorreverse &__r_cbyte) {return this->__p_vbyte==__r_cbyte.__p_vbyte;}
       bool operator   !=(const bytesiteratorreverse &__r_cbyte) {return this->__p_vbyte!=__r_cbyte.__p_vbyte;}
       int operator    *() {return *this->__p_vbyte;}
};

#ifndef _bytecontainer_
#define _bytecontainer_


class bytes {
   protected:
       byte        *__p_vbytes;
       size_t      _ln;

   public:
       typedef bytesiterator               iterator;
       typedef bytesiteratorreverse        reverse_iterator;

       bytes ( const byte* __p_vbytes , size_t _ln) {
           this->__p_vbytes    = new byte[_ln];
           this->_ln           = _ln;
           memcpy( this->__p_vbytes , __p_vbytes , _ln );
       }
       bytes ( ) {
           this->__p_vbytes    = NULL;
           this->_ln           = 0;
       }
       bytes ( size_t _ln ) {
           this->__p_vbytes    = new byte[_ln];
           this->_ln           = _ln;
           memset( this->__p_vbytes , 0 , _ln );
       }
       virtual ~bytes () { delete[] this->__p_vbytes; }

       size_t  leght() { return this->_ln; }
       byte*   __p()   { return this->__p_vbytes; }
       void clear()    { if ( this->__p_vbytes ) delete[] this->__p_vbytes; this->_ln = 0; }

       iterator begin() {
           //bytesiterator _v_tmp( (const byte*)this->__p_vbytes );
           iterator _v_tmp( (const byte*)this->__p_vbytes );
           return _v_tmp;
       }

       iterator end() {
           //bytesiterator _v_tmp( (const byte*)(&this->__p_vbytes[this->_ln]) );
           iterator _v_tmp( (const byte*)(&this->__p_vbytes[this->_ln]) );
           return _v_tmp;
       }

       reverse_iterator rbegin() {
           //reverse_iterator _v_tmp( (const byte*)(&this->__p_vbytes[this->_ln-1]) );
           reverse_iterator _v_tmp( (const byte*)(&this->__p_vbytes[this->_ln-1]) );
           return _v_tmp;
       }

       reverse_iterator rend() {
           //reverse_iterator _v_tmp( (const byte*)(this->__p_vbytes-sizeof(byte)) );
           reverse_iterator _v_tmp( (const byte*)(this->__p_vbytes-sizeof(byte)) );
           return _v_tmp;
       }

       bytes &operator+=( bytes &__p_cbyte) {
           byte    *__p_vbytes = this->__p_vbytes;
           size_t  _ln         = 0;
           size_t  _pos        = 0;
           if ( __p_cbyte.__p_vbytes!=NULL && __p_cbyte._ln>0 ) {
               if ( this->_ln>0 && this->__p_vbytes!=NULL ) {
                   _ln = this->_ln + __p_cbyte._ln;
                   _pos = this->_ln;
               } else {
                   _ln = __p_cbyte._ln;
               }
               __p_vbytes = new byte[_ln];
               memcpy( &__p_vbytes[_pos] , __p_cbyte.__p_vbytes , __p_cbyte._ln );

               if ( this->__p_vbytes!=NULL && this->_ln>0 ) {
                   memcpy( __p_vbytes , this->__p_vbytes , this->_ln );
                   delete[] this->__p_vbytes;
               }
           }
           this->__p_vbytes    = __p_vbytes;
           this->_ln           = _ln;
           return *this;
       }

       bytes &operator=( bytes &__p_cbyte ) {
           byte    *__p_vbytes = NULL;
           if ( this != &__p_cbyte ) {
               this->_ln           = __p_cbyte._ln;
               if ( this->_ln>0 && __p_cbyte.__p_vbytes != NULL ) {
                   __p_vbytes          = new byte[this->_ln];
                   memcpy( __p_vbytes , __p_cbyte.__p_vbytes , this->_ln );
               } else {
                   this->_ln           = 0;
               }
               delete[] this->__p_vbytes;
               this->__p_vbytes = __p_vbytes;
           }
           return *this;
       }

       operator byte*() {
           return this->__p_vbytes;
       }

       operator size_t() {
           return this->_ln;
       }

       operator long int() {
           return (long int)this->_ln;
       }

       operator unsigned long int() {
           return (unsigned long int)this->_ln;
       }

       bool operator ==( bytes &__pc_byte ) {
           size_t  _szt_pos    = 0;

           if ( __pc_byte.__p_vbytes == this->__p_vbytes ) {
               return true;
           }
           if ( (this->_ln == __pc_byte._ln) && (__p_vbytes != NULL) && (this->__p_vbytes!=NULL) ) {
               while ( _szt_pos<this->_ln ) {
                   if ( __pc_byte.__p_vbytes[_szt_pos] == this->__p_vbytes[_szt_pos] ) {
                       _szt_pos++;
                   } else {
                       return false;
                   }
               };
               return true;
           }
           return false;
       }
};
#endif  //#ifndef _bytecontainer_

#endif // cbyte_H



P.D.: Revise esta liga http://www.cplusplus.com/reference/std/iterator/reverse_iterator/reverse_iterator/ pero cuando la implemento no me sirve ( con respecto a esta clase ).

Dulces Lunas!¡.

[Keep_it_real]

.
Te recomiendo que pruebes a usar el lenguaje con el que te acomodes mas te recomiendo C/C++, yo empece con vb6 y aprendí bastante (punteros, referencias, enumeraciones, estructuras, métodos/funciones estáticos, etc... ) en este lenguaje lo que si no aprendí hay fue heredar, sobrecargas de funciones/procesos/operadores/etc, pero eso fue como de kinder ya en C++ con una buena lectura.

No te recomiendo que te entrañes con un lenguaje explora y compara por ti mismo, las personas solo te daremos opiniones personales, pero el argumento mas importante seria el tuyo, revisa el link que te ofreció Keep_it_real.

VB tiene una complejidad cuando se sabe el como hacer algo y se le conoce cada aspecto, dado que si no saben usar este lenguaje de programación (Basic mas que nada) entonces estas frito al opinar; en Basic se pueden manejar punteros, referencias, acceder a la memoria de otros programas, ejecutar ASM inline ( en vb6 hay que implementar los opcodes de cada instrucción,  ), CREAR S.O. (esto me sorprendió no hace mucho), y en un aspecto básico C y BASIC es lo mismo, cada uno por si solo son solo instrucciones básicas, controles de flujo, ciclos, entre otros, aun que ambos se expanden con las librerias o el ASM inline.

Temibles Lunas!¡.

[n]

.

Este codigo sigue la secuencia hasta n Longitud dada.

Código (vb) [Seleccionar] Expandir



Option Explicit

Private Sub Form_Load()
Dim v As Variant
    For Each v In iteraccion(20)
        Debug.Print v
    Next
End Sub

Public Function iteraccion(ByVal llen As Long) As Long()
Dim i       As Long
Dim c       As Long
Dim t       As Long
Dim vares() As Long
    llen = (llen - 1)
    ReDim vares(0 To llen)
    c = 1
    For i = 0 To llen Step 5
        vares(i) = c: t = i + 1
        If (t < llen) Then
            vares(t) = 15: t = t + 1
            If (t < llen) Then
                vares(t) = 10: t = t + 1
                If (t < llen) Then
                    vares(t) = 5: t = t + 1
                    If (t < llen) Then
                        vares(t) = 0: c = c + 1
                    End If
                End If
            End If
        End If
    Next i
    iteraccion = vares()
End Function



... de una manera mas simple.

Código (Vb) [Seleccionar] Expandir



Option Explicit

Private Sub Form_Load()
Dim v As Variant
    For Each v In iteraccion(21)
        Debug.Print v
    Next
End Sub
Public Function sets(ByVal lval As Long, ByRef vaArr() As Long, ByVal index As Long, ByVal lub As Long) As Long
    If Not ((index And &H80000000) = &H80000000) Then
        If (index <= lub) Then
            vaArr(index) = lval
            sets = (index + 1)
            Exit Function
        End If
    End If
    sets = &H80000000
End Function
Public Function iteraccion(ByVal llen As Long) As Long()
Dim i       As Long
Dim c       As Long
Dim vares() As Long
    llen = (llen - 1)
    ReDim vares(0 To llen)
    c = 1
    For i = 0 To llen Step 5
        vares(i) = c
        sets 5, vares(), sets(10, vares(), sets(15, vares(), (i + 1), llen), llen), llen
        c = c + 1
    Next i
    iteraccion = vares()
End Function



Dulces Lunas!¡.

.
"Ambas partes son coladeras" y hasta ahora no hay ningún software que no tenga ni un solo bug, sea software de pago o libre ( Por ejemplo los antivirus algunos detectan X virus que otros no, o sus falsos positivos aun que esto dependa de una BDD ).

Esta genial que una universidad haya metido las manos en el asunto, también esta genial que M$ haya hecho lo suyo para su navegador y no el de los demás, de manera segura es que una empresa JAMAS beneficiara a otra cuando sabe que la competencia le esta quitando terreno.

Dulces Lunas!¡.

.
mis 4 novias perdidas!¡, ... si son 4 verdad?  .

P.D.: Me encantaría ver a un mago hacer su "magia" tras una cámara phantom

Sexys Lunas!¡.

.
No te dire que uses option explicit, ni que intentes, bueno nada, solo si gustas sigue leyendo:

Según veo y con ese trozo de código te falta el proceso  "edccde", de igual manera dinos que error te salta, y de paso lee algo básico sobre programación ( POO, programación modular, programación genérica aun que este ultimo se trabaja mucho en vb6 que digamos ), ya que lo único que deberás esperar de la ignorancia sobre el tema es que te lleguen a hablar con tecnicismos.

En conclusión o aprendes algo básico para así TRATAR de arreglar un problema X o contratas a alguien que sepa o le pides todo completo a tu amigo.

Nota: Tu problema no es el código es la ignorancia hacia una campo, como lo es mi ignorancia hacia otros campos como la Química por ejemplo.

Nos vemos seguiré viendo mi película xP.

Dulces Lunas!¡.

[que puedan emplearse para crear]

.. o herramientas similares que puedan emplearse para crear botnets ...

Hay madre, los lenguajes de programación también? esto si que estará medio "chucho".

P.D.: Bromeo

Dulces Lunas!¡.

[Un Array es una sucesión Finita de variables de un mismo tipo que se distinguen por la posición en memoria una tras otra y son invocadas por indices de una declaración con un mismo nombre]

.
Haber si entiendo quieres pasar TODO de tu array byte a un array que contenga numeros en hexadecimal?, si es eso no necesitas el array byte sino seria un array string, ya que el hexadecimal es un numero pero alfanumérico mas no numérico de manera explicita.

es decir el byte es para NÚMEROS de intervalo cerrado [0-255] mientras que el String es para texto, números, símbolos, etc y es la mejor opción para los números hexadecimales.

aun que hay otra opción que es crear un modulo de clase y encapsular una funcion que te retorne un numero del array byte en Hexa, pero eso seria una exageración para algo tan trivial.

P.D.: Un Array es una sucesión Finita de variables de un mismo tipo que se distinguen por la posición en memoria una tras otra y son invocadas por indices de una declaración con un mismo nombre, de modo que si sabes hacerlo para una variable y un textbox sabrás hacerlo en un array.

Dulces Lunas!¡.

.
Cada elemento de el array esta en base 10 solo debes convertirlo a hexadecimal:

http://es.wikipedia.org/wiki/Sistema_hexadecimal

hay varios códigos en el foro que hacen esto.

Dulces Lunas!¡.