大内存区域上的按位或 [英] Bitwise OR on large memory regions
问题描述
亲爱的读者,
或两个大内存区域的有效方式是什么?
我对申请特别感兴趣此操作为两个大的
字符数组。我知道memset和memcopy让你初始化或复制
这个数组的速度非常快,但有没有相似的函数用于按位OR?
感谢您的帮助!
Best,
Oswald
[见 http://www.gotw.ca/resources/clcm.htm 有关的信息]
[comp.lang。 C ++。主持。第一次海报:做到这一点! ]
os**********@web.de 写道:
有两种大内存区域的有效方法是什么?
我特别感兴趣的是将这个操作应用于两个大的
字符数组。我知道memset和memcopy可以让你初始化或者b / b
非常快速地复制这个数组,但是
是否有类似的函数按位OR?
我会用
模板<类Tstruct binOR:std :: binary_function< T,T,T {
T operator()(const T& x,const T& y)const {
return x | y;
}
};
...
std :: transform(begin1,end1,begin2 ,输出,二进制);
并希望编译器能够优化这些东西。
别忘了包括< ; functionaland< algorithm> ;.
V
-
请在回复时删除资本''A'电子邮件
我没有回复最热门的回复,请不要问
Oswald发布:
< blockquote class =post_quotes>
有两种大内存区域的有效方法是什么?
这里有一个想法:
如果是unsigned int没有陷阱表示,那么或者记忆就好像你正在使用一组无符号整数。
#include< cstddef>
#include< cassert>
unsigned * ArrayOR(unsigned const * p1,unsigned const * p2,std :: size_t len)
{
断言(p1);
断言(p2);
断言(len);
unsigned * const retval = new unsigned [len];
unsigned * p = retval;
do * p ++ = * p1 ++ | * P2 ++; while( - len);
返回retval;
}
然后执行以下操作:
void * MemOR(void const * const p1arg,
void const * const p2arg,
std :: size_t const bytes)
{
unsigned char const * p1 = p1arg;
unsigned char const * p2 = p2arg;
/ *正确对齐指针,然后
稍后清理任何多余的字节。 * /
ArrayOR(p1,p2,a,amount_int); / *必要的演员* /
/ *现在处理开头的额外字节
和结尾。 * /
}
-
Frederick Gotham
>
" Frederick Gotham" < fg ******* @ SPAM.com在留言中写道
新闻:eK ******************* @ news.indigo .ie ...
Oswald发布:
> OR有两种有效的方法大内存区域?
这里有一个想法:
如果是unsigned int没有陷阱表示,那么或者记忆就好像你正在使用一组无符号整数。
#include< cstddef>
#include< cassert>
unsigned * ArrayOR(unsigned const * p1,unsigned const * p2,std :: size_t len)
{
断言(p1);
断言(p2);
断言(len);
unsigned * const retval = new unsigned [len];
unsigned * p = retval;
do * p ++ = * p1 ++ | * P2 ++;而( - LEN);
Yuk。这是我讨厌在C ++中看到的东西。一切都在一个
行,充满了++和 - 。为什么不制作一个for循环,或者至少可读的循环?b
?优化器可能会将它解析为
结尾的相同代码。
>
返回retval ;
}
然后做类似的事情:
void * MemOR(void const * const p1arg,
void const * const p2arg,
std :: size_t const bytes)
{
unsigned char const * p1 = p1arg;
unsigned char const * p2 = p2arg;
/ *正确对齐指针,然后
清理任何稍后的额外字节。 * /
ArrayOR(p1,p2,a,amount_int); / *必要的演员* /
/ *现在处理开始时的额外字节
和结尾。 * /
}
你在ArrayOR中有新内存,但没有把它分配给任何东西。
除了没有使用结果,它是内存泄漏,呃?
如果海报想要就地OR,一个简单的循环就足够了,而不是
a函数:
for(int i = 0; i< len; ++ i)
a [i] | = b [i];
快速,简单,明显。我的那种C ++。 :-)
-Howard
Dear Reader,
what efficient ways are there to OR two large memory regions?
I''m especially interested in applying this operation to two large
character arrays. I know memset and memcopy lets you initialise or copy
this arrays very fast, but are there similar functions for bitwise OR?
Thanks for your help!
Best,
Oswald
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]
os**********@web.de wrote:what efficient ways are there to OR two large memory regions?
I''m especially interested in applying this operation to two large
character arrays. I know memset and memcopy lets you initialise or
copy this arrays very fast, but are there similar functions for
bitwise OR?I would use
template <class Tstruct binOR : std::binary_function<T,T,T{
T operator()(const T& x, const T& y) const {
return x | y;
}
};
...
std::transform(begin1, end1, begin2, output, binOR);
And hope that the compiler is capable of optimizing that stuff.
Don''t forget to include <functionaland <algorithm>.
V
--
Please remove capital ''A''s when replying by e-mail
I do not respond to top-posted replies, please don''t ask
Oswald posted:
what efficient ways are there to OR two large memory regions?
Here''s one idea:
If an "unsigned int" has no trap representations, then OR the memory as if
you''re OR-ing an array of unsigned integers.
#include <cstddef>
#include <cassert>
unsigned *ArrayOR(unsigned const *p1,unsigned const *p2,std::size_t len)
{
assert(p1);
assert(p2);
assert(len);
unsigned *const retval = new unsigned[len];
unsigned *p = retval;
do *p++ = *p1++ | *p2++; while(--len);
return retval;
}
Then do something like:
void *MemOR(void const *const p1arg,
void const *const p2arg,
std::size_t const bytes)
{
unsigned char const *p1 = p1arg;
unsigned char const *p2 = p2arg;
/* Align the pointers correctly, then
clean up any extra bytes later on. */
ArrayOR(p1,p2,a,amount_int); /* Casts necessary */
/* Now deal with the extra bytes at the start
and at the end. */
}
--
Frederick Gotham
"Frederick Gotham" <fg*******@SPAM.comwrote in message
news:eK*******************@news.indigo.ie...Oswald posted:
>what efficient ways are there to OR two large memory regions?
Here''s one idea:
If an "unsigned int" has no trap representations, then OR the memory as if
you''re OR-ing an array of unsigned integers.
#include <cstddef>
#include <cassert>
unsigned *ArrayOR(unsigned const *p1,unsigned const *p2,std::size_t len)
{
assert(p1);
assert(p2);
assert(len);
unsigned *const retval = new unsigned[len];
unsigned *p = retval;
do *p++ = *p1++ | *p2++; while(--len);Yuk. This is the kind of thing I hate to see in C++. Everything on one
line, full of ++ and --. Why not make a for loop, or a loop that''s more
readable at least? The optimizer will likely resolve it to the same code in
the end.
>
return retval;
}
Then do something like:
void *MemOR(void const *const p1arg,
void const *const p2arg,
std::size_t const bytes)
{
unsigned char const *p1 = p1arg;
unsigned char const *p2 = p2arg;
/* Align the pointers correctly, then
clean up any extra bytes later on. */
ArrayOR(p1,p2,a,amount_int); /* Casts necessary */
/* Now deal with the extra bytes at the start
and at the end. */
}
You''ve new''d memory there in ArrayOR, but not assigned it to anything.
Besides not using the results, it''s a memory leak, eh?
If the poster wanted an in-place OR, a simple loop would suffice, instead of
a function:
for (int i = 0; i < len; ++i)
a[i] |= b[i];
Quick, easy, and obvious. My kind of C++. :-)
-Howard
这篇关于大内存区域上的按位或的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!