[c++] byteweise ab einer Adresse zugreifen

[Speed]

Bin mir gerade mit dem Casten unsicher.
Wie kann ich auf einen beliebigen Adressbereich byteweise zugreifen? - im endefekt möchte ich mit einem short zeiger über ein belibiges Objekt navigieren um den Inhalt zuzugreifen.

[CStoll]

Zum byteweisen Zugriff verwendest du am besten einen char-Zeiger (und immer daran denken, daß du bei allem, was du dort machst, auf dich alleine gestellt bist).

[dot]

Speed schrieb:

im endefekt möchte ich mit einem short zeiger über ein belibiges Objekt navigieren um den Inhalt zuzugreifen.

Mal ganz abgesehen davon wie man es macht: Warum kannst du auf das Objekt nicht einfach "normal" zugreifen?

[Speed]

CStoll schrieb:

Zum byteweisen Zugriff verwendest du am besten einen char-Zeiger (und immer daran denken, daß du bei allem, was du dort machst, auf dich alleine gestellt bist).

hab mich verschrieben meinte natürlich char...
aber ich bin mir immer noch nicht sicher wie ich das genau umcaste ist das so richtig(falls doch dann kann man den thread schliesen ;-)?

aclass OBJ;
unsigned char* P= reinterpretcast< unsigned char*>(&Obj);

Wieso ich das möchte? - nur eine Spielerei : http://www.c-plusplus.net/forum/289557

[CStoll]

abgesehen davon, daß man reinterpret_cast<> mit einem Unterstrich schreibt, dürte das richtig sein. Aber wie gesagt, es ist nicht portabel was du dort zu sehen bekommst (davon abgesehen, daß du besser nicht in fremde Objekte über so einen Zeiger schreiben solltest - dazu mußt du schon sehr genau wissen, was du dort machst).

[314159265358979]

#include <iostream>
#include <iterator>

template <typename T, int N = sizeof T>
class bytewise_iterator : public std::iterator<std::random_access_iterator_tag, char>
{
        T& obj;
        char (&data) [N];
        unsigned index;

public:

        bytewise_iterator(T& o, int index = 0)
                : obj(o)
                , data(reinterpret_cast<char (&) [N]>(o))
                , index(index)
        {}

        bytewise_iterator& operator ++ ()
        {
                ++index;
                return *this;
        }

        bytewise_iterator operator ++ (int)
        {
                return bytewise_iterator(obj, index++);
        }

        bytewise_iterator& operator -- ()
        {
                --index;
                return *this;
        }

        bytewise_iterator& operator -- (int)
        {
                return bytewise_iterator(obj, index--);
        }

        char& operator * ()
        {
                return data[index];
        }

        bool operator == (const bytewise_iterator& rhs)
        {
                return &obj == &rhs.obj && index == &rhs.index;
        }

        bool operator != (const bytewise_iterator& rhs)
        {
                return !(*this == rhs);
        }
};

template <typename T, int N = sizeof T>
bytewise_iterator<T, N> begin(T& obj)
{
        return bytewise_iterator(obj);
}

tempalte <typename T, int N = sizeof T>
bytewise_iterator<T, N> end(T& obj)
{
        return bytewise_iterator(obj, N);
}

struct test
{
        char a;
        char b;
        char c;
};

int main()
{
        test t;
        t.a = 'a';
        t.b = 'b';
        t.c = 'c';

        for(bytewise_iterator<test> iter = begin(t); iter != end(t); ++iter)
                std::cout << *iter << std::endl;        
}

Ungetestet.

[Speed]

Du bist aber fix ;P
da haben sich aber ein paar fehler eingeschliechen
Korigierte version :

#include <iostream>
#include <iterator>

template <typename T, int N = sizeof(T)>
class bytewise_iterator : public std::iterator<std::random_access_iterator_tag, char>
{
        T& obj;
        char (&data) [N];
        unsigned index;

public:

        bytewise_iterator(T& o, int index = 0)
                : obj(o)
                , data(reinterpret_cast<char (&) [N]>(o))
                , index(index)
        {}

        bytewise_iterator& operator ++ ()
        {
                ++index;
                return *this;
        }

        bytewise_iterator operator ++ (int)
        {
                return bytewise_iterator(obj, index++);
        }

        bytewise_iterator& operator -- ()
        {
                --index;
                return *this;
        }

        bytewise_iterator& operator -- (int)
        {
                return bytewise_iterator(obj, index--);
        }

        char& operator * ()
        {
                return data[index];
        }

        bool operator == (const bytewise_iterator& rhs)
        {
                return (&obj == &rhs.obj) && (index == rhs.index);
        }

        bool operator != (const bytewise_iterator& rhs)
        {
                return !(*this == rhs);
        }
};

template <typename T, int N = sizeof(T)>
bytewise_iterator<T, N> begin(T& obj)
{
        return bytewise_iterator<T,N>(obj);
}

template <typename T, int N = sizeof(T)>
bytewise_iterator<T, N> end(T& obj)
{
        return bytewise_iterator<T,N>(obj, N);
}

struct test
{
        char a;
        char b;
        char c;
};

int main()
{
        test t;
        t.a = 'a';
        t.b = 'b';
        t.c = 'c';

        for(bytewise_iterator<test> iter = begin(t); iter != end(t); ++iter)
                std::cout << *iter << std::endl;
}

[Ethon]

Wieso ein abstraktes Konstrukt wie einen Iterator bauen um komplett typunsichere, low-level Speicheroperationen durchzuführen?
Ein Iterator hat hier genau 0 Vorteile gegebenüber nem Pointer.

Ich nehme mal an das Ganze ist was recht "hackishes" wie DLL Injection oä.

[314159265358979]

Iteratoren sind einfach viel cooler.