Я вызываю функцию следующим образом:
void do_work(void* ptr, size_t size)
{
//do things with ptr and size
}
Возникает вопрос: можно ли вызвать функцию do_work(one);
и как-то получить размер внутри функции?
Если one
является статическим массивом (int one[10];
) или non array (int one;
), возможно ли это сейчас?
Вы можете использовать шаблон функции:
template <typename T>
void do_work(T* stuff)
{
const size_t s = sizeof(T);
....
}
Изменить: версия для массивов:
template<typename T, size_t N >
void do_work(T (&array)[N] )
{
const size_t s = N * sizeof(T);
}
int one[10]
это возвращает 4. Я хочу, чтобы это вернуло 40, это возможно?
В C++ вы можете использовать вывод шаблона contumment, чтобы получить тип указателя (заостренный тип), а затем вычислить его sizeof:
template<typename T>
void do_work( T* ptr )
{
constexpr std::size_t size = sizeof(T);
}
T
не является POD-типом, это может быть проблемой ( sizeof()
не возвращает того, что мы ожидаем), например, проблемы с vptr для полиморфных классов, заполнения и т. Д. Но это не проблема, sizeof()
только делает то, для чего предназначен dessigned, вычисляет размер экземпляра типа, верно? Это вы, как пользователь, должны быть осторожны с ожидаемыми результатами и их результатами. Однако, учитывая присвоение (функция, которая принимает void*
и размер), я предположил, что это функция, связанная с работой с POD, такими как memcpy()
ing и т. Д.
Нет, не для void *
, вы не сможете вычислить размер объекта, адрес которого передан.
template<typename T>
void do_work(T* ptr)
{
size_t size = sizeof(T);
size = sizeof(*ptr); // or this
}
sizeof(type)
до C ++ 11?
typeid
.
template <typename T>
void do_work(T * t) { do_work(t, sizeof(T)); }
sizeof(t)
размер самого указателя здесь?
Если я получу вас правильно, вы можете захотеть:
#include <iostream>
void do_work(void* ptr, size_t size)
{
std::cout << "Size: " << size << '\n';
}
template <typename T>
void do_work(T& single) {
do_work(&single, 1);
}
template <typename T, std::size_t N>
void do_work(T (&array)[N]) {
do_work(array, N);
}
template <typename T>
void do_work(T* multiple, std::size_t n) {
do_work(static_cast<void*>(multiple), n);
}
int main()
{
int a = 1;
int b[] = { 1, 2, 3 };
int* c = b;
do_work(a);
do_work(b);
do_work(c, 3);
}
Примечание: Почему пустота *?
Я не знаю C++, этот вопрос появился передо мной, возможно, потому, что раньше он имел бирку C. Но здесь что-то, что вы могли бы сделать на C, возможно, также в C++:
#define do_work(_a_) do_work_func(_a_, sizeof(_a_))
void do_work_func( void* ptr, size_t size )
{
//do things with ptr and size
}
Это сработало бы, учитывая, что one
в do_work( one );
вызов был определен как массив.