Кастинг массива неподписанных символов к массиву плаваний

I think the best way is to use a function object:

template <typename T> // T models Any
struct static_cast_func
{
  template <typename T1> // T1 models type statically convertible to T
  T operator()(const T1& x) const { return static_cast<T>(x); }
};

followed by:

std::transform(char_buff, char_buff + len, float_buff, static_cast_func<float>());
std::transform(float_buff, float_buff + len, char_buff, static_cast_func<unsigned char>());

This is the most readable because it says what is being done in English: transforming a sequence into a different type using static casting. And future casts can be done in one line.

Ваше решение в значительной степени является лучшим вариантом, однако я бы подумал о переходе на:

char_buff[i]= static_cast<unsigned char>(float_buff[i]);

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

С какой целью вы это делаете? Вставить поплавок в полукокса не имеет смысла. На большинстве платформ число с плавающей запятой будет 4 байта и представляет число с плавающей запятой, где как символ будет 1 байт и часто представляет один символ. Вы потеряете 3 байта данных, пытаясь засунуть float в символ, верно?

Ваш первый цикл не требует приведения. Вы можете неявно конвертировать из одного типа (например, unsigned char ) в более широкий тип (например, float ). Ваш второй цикл должен использовать static_cast :

for (i=0; i< len; i++)
    char_buff[i]= static_cast<unsigned char>(float_buff[i]);

Мы используем static_cast , чтобы явно указать компилятору выполнить преобразование в более узкий тип. Если вы не используете приведение, ваш компилятор может предупредить вас, что преобразование может потерять данные. Наличие оператора приведения означает, что вы понимаете, что можете потерять точность данных, и с этим все в порядке. Это не подходящее место для использования reinterpret_cast . С static_cast вы по крайней мере имеете некоторые ограничения на то, какие преобразования вы можете сделать (например, это, вероятно, не позволит вам преобразовать Bird * в Nuclear_Submarine * ]).

Я нашел ответ на этих двух веб-сайтах: Net Maniac и Aimred .

Вам нужно иметь версию> 0.8 рейка использовать эту технику

Обычное описание задачи с граблями таково:

desc 'Task Description'
task :task_name => [:depends_on_taskA, :depends_on_taskB] do
  #interesting things
end

Чтобы передать аргументы, сделайте три вещи:

1. Добавьте имена аргументов после имени задачи, разделив их запятыми.
2. Поместите зависимости в конец использования: needs => [...]
3. Place | t, args | после того как (t является объектом для этой задачи)

Чтобы получить доступ к аргументам в сценарии, используйте args.arg_name

desc 'Takes arguments task'
task :task_name, :display_value, :display_times, :needs => [:depends_on_taskA, :depends_on_taskB] do |t, args|
  args.display_times.to_i.times do
    puts args.display_value
  end
end

Чтобы вызвать эту задачу из командной строки, передайте ей аргументы в [] s

rake task_name['Hello',4]

выведут

Hello
Hello
Hello
Hello

, и если вы хотите вызвать эту задачу из другой задачи и передать ей аргументы, используйте invoke

task :caller do
  puts 'In Caller'
  Rake::Task[:task_name].invoke('hi',2)
end

, тогда команда

rake caller

выведет

In Caller
hi
hi

. Я не нашел способа передать аргументы как часть зависимости , Но вы можете использовать стандартные алгоритмы:

std::copy(char_buff,char_buff+len,float_buff);

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

std::transform(float_buff,float_buff+len,char_buff,MyTransform());

Здесь мы используем класс MyTransform, который должен иметь оператор (), который принимает значение с плавающей точкой и возвращает символ. Это должно быть тривиально для импликации.

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

   float *dst = float_buff;
   unsigned char *src = char_buff;

   for (i=0; i<len; i++) *dst++ = (float)*src++;

Никто не упомянул об этом, но если вы выполняете какие-либо арифметические операции с числами с плавающей запятой, вы можете округлять вместо усечения ... если у вас есть символ 49, и он поворачивается в 4.9E1, после некоторой арифметики, он может превратиться в 4.89999999E1, который превратится в 48, когда вы превратите его обратно в символ.

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