我想知道分配给指针的大小.
所以我找到了这个答案: 我怎么知道c中指针变量的分配内存大小
它有以下代码.
#include <stdlib.h>
#include <stdio.h>
void * my_malloc(size_t s)
{
size_t * ret = malloc(sizeof(size_t) + s);
*ret = s;
return &ret[1];
}
void my_free(void * ptr)
{
free( (size_t*)ptr - 1);
}
size_t allocated_size(void * ptr)
{
return ((size_t*)ptr)[-1];
}
int main(int argc, const char ** argv)
{
int * array = my_malloc(sizeof(int) * 3);
printf("%u\n", allocated_size(array));
my_free(array);
return 0;
}
这条线(((size_t*)ptr)[-1])很完美,但我不明白为什么......
有人能帮我理解这条神奇的线条吗？谢谢!
我有两个方法“log”和“measure”，它们永远不应该同时执行。所以我尝试使用“std::mutex”来执行此操作，如下所示：
void log(std::string message)
{
mtx.lock();
someLogFunctionality();
mtx.unlock();
}
void measure()
{
mtx.lock();
someMeasureFunctionality();
mtx.unlock();
}
现在事实证明，还可以在不锁定的情况下并行多次调用“log”，这同样适用于“measure”。（原因：someLogFunctionality() 和 someMeasureFunctionality() 互相干扰，但同一个方法可能会并行调用多次）
然后我查看了“std::shared_mutex”，但对我来说有两个问题：
1.）使用shared_mutex，我只能将lock_shared用于其中一种方法（日志或测量），但另一个方法必须使用排他锁（并且不能再次并行执行多次）
void log(std::string message)
{
mtx.lock_shared();
someLogFunctionality();
mtx.unlock_shared();
}
void measure()
{
mtx.lock(); // This should also be shared but among another "group"
someMeasureFunctionality();
mtx.unlock();
}
2.）我无法使用C++17（受我正在使用的环境的限制）
您对我如何实现这一点有什么建议吗？
我有兴趣在添加无符号8位整数时识别溢出值,并将结果饱和到0xFF:
__m128i m1 = _mm_loadu_si128(/* 16 8-bit unsigned integers */);
__m128i m2 = _mm_loadu_si128(/* 16 8-bit unsigned integers */);
__m128i m3 = _mm_adds_epu8(m1, m2);
我会感兴趣的是执行比这些无符号整数更少的比较,类似于_mm_cmplt_epi8签名:
__m128i mask = _mm_cmplt_epi8 (m3, m1);
m1 = _mm_or_si128(m3, mask);
如果"epu8"等效可用,mask必须0xFF在那里m3[i] < m1[i](溢出!) 0x00 otherwise,我们将能够饱和m1使用"或",所以m1将持有另外的结果,其中有效的,0xFF它溢出.
问题是,_mm_cmplt_epi8执行符号比较,因此,例如,如果m1[i] = 0x70和m2[i] = 0x10,然后m3[i] = 0x80和mask[i] = 0xFF,这显然不是我的要求.
使用VS2012.
我希望采用另一种方法来执行此操作.谢谢!
可能重复:
如何在构造函数中初始化const字段？
我有这门课:
class Foo {
private:
...
public:
Foo() : ... {}
// no other constructors
...
};
另一个通过引用持有Foo成员的人:
class Bar {
private:
const Foo& m_foo;
...
public:
Bar(const Foo& foo);
// no other constructors
};
我的问题是:如何在构造函数中初始化Bar :: m_foo引用？
谢谢!
#include<stdio.h>
int main()
{
int a = 0, b = 1, c = 2;
*((a+1 == 1) ? &b : &a) = a ? b : c;
printf("%d, %d, %d\n", a, b, c);
return 0;
}
程序的输出是0,2,2.条件语句如何改变C中变量b的值？
我搜索但我找不到相关的问题.如果我错了,请纠正我.
在我的项目中,我使用以下内容:
using namespace std;
using namespace sf;
我希望它像下面一样.
using namespace std, sf;
提前致谢!
遵循其他语言中的类似模式，我有兴趣在 Kotlin 中生成对原始类型进行强类型化的最有用的方法。
当然，其基本原理是拥有两种基本类型（例如字符串），但不能错误地相互分配。
我的最新尝试在这里给出，我有兴趣知道如何进一步最小化它（可以省略定义派生构造函数吗？）
abstract class StronglyTyped<T>{
private var value: T
constructor(_value: T) {
value = _value
}
operator fun invoke(): T {
return value
}
}
class UserId: StronglyTyped<String> {
constructor(_value: String): super(_value) {}
}
class UserName: StronglyTyped<String> {
constructor(_value: String): super(_value) {}
}
fun main() {
val a = UserId("this is a userId")
val b = UserName("this is a userName")
var c: UserName
//c = a // <== won't compile
c = b
println(c())
}
为什么这个递归函数落入无限循环？它显示Val的价值没有下降.背后的逻辑是什么？
int Bar(int Val) // value passed is 3
{
int x=0;
while (Val>0)
{
x=x+Bar(val-1);
}
return Val
}