C++ Void non-pointer

Question

Мне было интересно, почему не может быть тип данных void, который не является указателем?

Конечно, вы могли бы пройти весь определенный размер вещи, имея

void4 
void8 
void32 

и только разрешают «отбрасываемой» типа аннулируются данных к другому классу, если его размер равен или под с размером классов ,

Есть ли что-то, что мне не хватает, или комитет C++ просто считает это плохой практикой?

EDIT:

Я не объяснил себя очень хорошо, так что я дам пример ее использования:

main() 
{ 
    /* 

    Lets make a list of unknown elements 

    std::string is 8 bytes, and float is 4 
    bytes, so we'll reserve 8 byte sequences 

    */ 

    vector<void8> elements; 

    elements.push_back((void8) string("First string element")); 

    elements.push_back((void8) float(5.76)); 

    elements.push_back((void8) string("Third string element")); 

    // Ect. 

    cout << (string) elements[0]; 
    cout << (float) elements[1]; 
    cout << (string) elements[2]; 
    cout << (float) elements[2]; // Garbage 


    void1 data; 

    data = (void1) bool(1); 
    data = (void1) unsigned int(80094); // Error, not enough size 
} 

Его назвали недействительным, потому что вы не знаете, какой тип это в настоящее время хранится, подобно указателю void.

Answer 1

В строго типизированном языке все данные имеют тип, поэтому нет понятия «пустота» в качестве типа данных. В C и C++ это значения либо «нет данных» (как возвращаемое значение), либо «данные, тип которых вы не знаете» (в качестве цели указателя).

Вы предлагаете промежуточное состояние «данных, тип которых вы не знаете, но размер которого вы делаете», предположительно как непрозрачную версию типа, которую вы передаете по значению. Помимо того, что вы довольно опасны (поскольку вам нужно вручную обновлять весь код с помощью непрозрачного типа при изменении размера реального типа), это уже можно сделать без добавления странных расширений к языку, например:

struct void8 { char bytes[8]; }; 

Этот мог быть использовано в сочетании с reinterpret_cast передать типы POD вокруг, как непрозрачные комочки, во многом так, как вы предлагаете. Использование его с не-POD-типами, скорее всего, вызовет неопределенное поведение, чем использование void* для обозначения типов, отличных от POD.

Было бы безопаснее и более идиоматично обрабатывать непрозрачные типы в качестве указателей или ссылок на именованные типы, которые были объявлены, но не определены, или что-то вроде boost::any, если вы хотите семантику значений. В C++ редко используется «пустота» в качестве типа заполнителя.

Answer 2

Что будет означать тип данных «пустота»? Я не думаю, что есть действующий, так что, вероятно, поэтому его не существует.

Answer 3

Что недействительно? Это ничего, пустота. Void32, lol! void используется для обозначения функции, которая ничего не возвращает. В других языках есть ключевое слово «procedure» или «sub». Указатель на void - указатель на неизвестный (второе использование void). Это две цели.

Обновление: Я думаю, автор хочет обозначить неизвестный тип с известным размером. void32 * - указатель на какой-либо объект с размером 32 бита, void8 * - указатель на 8-битные объекты и т. д. Но он легко эмулируется с помощью int32 *, char * без расширения языка.

Answer 4

Наличие типа данных в пустоте излишне усложняло бы вещи. и более того, что будет делать тип данных, если он называется void.

Я думаю, вы имеете в виду тип данных, который может функционировать как пустой, но вы можете изменить имя и не называть его void.

Answer 5

Что вы ищите уже существует. Он называется char. Массив из char может использоваться для хранения неизвестных объектов, потому что char в основном является именем C++ для байта. Таким образом, чтобы хранить неизвестные или переменные типы объектов в одном массиве, вы используете массив байтов, а не массив ничего, что было бы void.

Точка в указателе void заключается в том, что мы не знаем, на что он указывает. Мы не знаем размер объекта, на который он указывает. Так что void4 не имеет большого смысла. Мы больше не «пусто», если знаем размер объекта. Единственное, что мы можем сделать с неизвестным объектом, это указать на него. Мы не можем хранить его в любом месте, потому что мы не знаем, является ли он объектом POD, и мы не знаем, насколько он величен или его требования к выравниванию. Поэтому мы, конечно, не храним его в массиве. Все, что мы можем сделать, это создать указатель на него, и у нас уже есть указатели void.

И, конечно же, забавный вопрос:

Какой типа T здесь?

void foo(void* p) { 
    T q = *p; 
} 

void4? void32? Или просто void? Насколько большой должен быть объект? Что мы знаем об этом? Это тип POD?

Answer 6

Это называется boost :: variant или boost :: any. Это размер максимально допустимого типа данных + sizeof (указатель) и полностью безопасен по типу.

Answer 7

void* не является указателем, который является недействительным, как в недействительном. Это указатель на void, так как в нем ничего нет.

Тип типа void сам определяется отсутствием значения. В представлении нет битов. Он не может создавать объекты.

То, что вы описываете, может быть отправлено в и из. Поэтому он содержит информацию. Поэтому это не пустая пустота.

То, что вы описываете, это просто int, где численное значение игнорируется. Но предлагаемое использование - это плохая практика.

Answer 8

void является «необитаемым» типом, то есть нет возможных значений типа void. Поскольку нет возможных значений, для хранения void не требуется свободного места. Поэтому значения void были бы бессмысленными.

Переход назад: C и C++ довольно последовательно распознают void как значение «ничего». Вы можете иметь указатель на ничего и использовать его для переноса значения указателя на что-то вокруг, но вы не можете его разыменовать - void не имеет никакого значения, с которым вы можете что-либо сделать.

Следует также отметить, что void не -это-ничто несет через к делу указатель недействительным: в то время как некоторые компиляторы, такие как GNU позволяют делать арифметические операции над указателями на void* значения, как если бы они были char*, стандарты запрещают арифметику указателей на void* потому что, поскольку void ничего, у него нет значимого размера.

Итак, я думаю, что ответ таков: это было бы бессмысленно.void ничего, и вы ничего не можете хранить в значении.

Answer 9

Я собираюсь предположить, что вы знаете немного больше о вещах, которые вы будете хранить, чем о их размере, иначе я не верю, что есть много пунктов в хранении этих предметов.

Я думаю, что вы можете взглянуть на профсоюзы. Объединение резервирует достаточно места для хранения наибольшего члена профсоюза, а затем в зависимости от того, как вы ссылаетесь на союз, выбирает «подходящее» количество пространства и дает его вам как тип, который вы запрашиваете.

Это очень похоже на то, что вы производите массив символов независимо от того, что вы на самом деле ищете, вы должны много думать, прежде чем использовать эту функцию.

Answer 10

Если бы был тип данных в пустоте, я думаю, что он не должен представлять ничего и просто проглотить что-либо, что хранится в нем.

вы можете сказать

(void)func1(); 

так почему бы не

void x; 
x = func1(); 

или

void func2() { 
    void x; 
    ... 
    return x; 
} 

и в качестве аргумента функции

int func3(int x, void y, char z); 

void x = func3(1,2); 
x = func3(1,x,2); 

Использование void в выражении является ошибкой

Я вижу, как это используется в некоторых кодировках шаблонов.