Сдвиг указателя на желаемое количиство байт

[220Volt]

Доброго дня.
Встроенные операции над указателями жестко привязаны к типу указателя, а как грамотно сдвинуть указатель на произвольное количество байт? Сразу могут прийти варианты:

int *p = (int*)d;
p = (int*) ((int)p + sizeof(double));        // #1
    
nt *p2 = (int*)d;
p2 = (int*) ((char*)p2 + sizeof(double));    // #2

Но в #1 я привязываюсь к размеру конкретного типа, а размер указателей будет всегда расти и однажды произойдет переполнение. В #2 привязка к размеру другого типа, а везде ли char 1 байт? Для меня это не ясно (насколько мне известно, его размер не более двух байт). Поэтому вопрос: как делать подобную операцию правильно, чтобы не пришлось ее редактировать из-за роста указателей или разных размеров типов на разном оборудовании? В голове крутится мысль о том что возможно для этих целей есть что-то в std. Или какой-то std typedef размер которого будет достаточен для хранения любого адреса.

[waleri]

Ну если подходить так строго, то никак - размер char не определен, но его можно узнать из CHAR_BIT. Раз так уж важно, можете сделать так:
((char*) ptr) + (sizeof(double) / sizeof(char))

Второй вариант, вынести все это в функцию, которая может быть имплементирована по разному на разных архитектурах.

Я думаю надо будет очень постараться, чтоб найти С компилятор и/или архитектуру, где char != 8 бит

Массив - не всегда самый удачный способ хранения данных. Сделайте массив указателей а указатель может быть на любого наследника. Даже в базах данных таблицы содержат "одинаковые" структуры.

[220Volt]

Спасибо.
Я покопался в справочнике вот что нашел http://www.cplusplus.com/reference/cstdint/:

intptr_t uintptr_t Integer type capable of holding a value converted from a void pointer and then be converted back to that type with a value that compares equal to the original pointer.
Optional: These typedefs may not be defined in some library implementations.*

Поэтому на мой взгляд вполне верным и безопасным является вариант:

#include <iostream>
#include <cstdint>

using namespace std;

    
int main()
{
    double d[2];
    
    int *p = (int*)d;
    p = (int*) ((uintptr_t)p + sizeof(double)); 
    
    cout << &d[1] << "\n" << p;
    
    return 0;
}

[220Volt]

Сообщение от waleri

... Раз так уж важно, можете сделать так:
((char*) ptr) + (sizeof(double) / sizeof(char))

...

Пользовательский тип ведь необязательно кратен двум, например:

struct S
{
    char ar[9];
};

[ROD]

<тут было что-то страшное>

[220Volt]

А зачем это нужно?
Недавно заводил тему http://www.programmersforum.ru/showthread.php?t=251137.
Так вот такое решение у меня получилось:

#include <iostream>
#include <cstdint>
#include <type_traits>

using namespace std;

template <typename _Ty>
    class Array_wrapper
    {
        _Ty *array;
        size_t el_size;
    public:
        template <typename _Ar_Ty>
            Array_wrapper(_Ar_Ty *array)
            {
                static_assert(is_base_of<_Ty, _Ar_Ty>::value, "_Ar_Ty is not derived from _Ty");

                this->el_size = sizeof(_Ar_Ty);
                this->array = array;
            }
            
        _Ty &operator[](size_t index)const
        {
            return *(_Ty*) ((uintptr_t)this->array + this->el_size * index);
        }
    };

struct S                
{ 
    int t; 
};

struct S2 : public S    
{ 
    int q;
};

void f(const Array_wrapper<S> &ps, int size)
{
    for(int i = 0;  i < size;  ++ i)
        cout << ps[i].t << "\n";
}

int main()
{
    constexpr int size = 5;
    S2 ar[size];
    
    for(int i = 0;  i < size;  ++ i)
        ar[i].t = ar[i].q = i;
    
    f(Array_wrapper<S> {ar}, size);
    
    return 0;
}

Теперь все работает правильно, мне нравится. Допускаю что возможно я плохо знаю std и что-то подобное там уже есть. Думаю не всегда удобно сделать функцию f() шаблонной и подобный трюк может помочь.