标签: void-pointers

以下是代码的上下文:

void THREAD_CC server_thread(void *arg)
{
    BIO *client = (BIO *)arg;
        ...
}

表达式是否将(BIO *)argvoid指针arg转换为指向BIO的指针？我不确定我是否正确.

任何帮助将非常感激!

Z.Zen

我需要一个包含任何用户定义类的实例的变体类型.所以我使用void*:

typedef boost::variant<void*, int, float, std::string> Tvariant;

我用地图创建了一个包装类:

typedef std::map<std::string, Tvariant> Tvalues;

用法示例:

int x = 123;
attributes.set("int_var", x);
x = attributes.get<int>("int_var");

MyClass* obj = new MyClass();
attributes.set("void*_var", obj);
obj = static_cast<MyClass*>( attributes.get<void*>("void*_var") );
obj = attributes.cast<MyClass*>("void*_var"); // the same

变体类中的void*有2个问题:

1. 使用指向动态分配的内存的指针复制属性是危险且容易出错的.
2. 用户可以static_cast void*到WrongClass*,而不是MyClass*.它编译,但结果是不可预测的.

可能的解决方案:

1. 使用boost :: shared_ptr <void*>.
2. 记住所有void*值的typeid(当它们被添加时)std::map<void*, typeid> typeid_map.当用户请求void*value,将其转换为任何TClass*时,让我们评估一个断言:assert(typeid_from_typeid_map == typeid(TClass*)).

问题:
1.是否有其他解决方案来保存任何用户定义的类的值？
2.您可能会为上述问题推荐更好的解决方案并指出其他一些问题吗？

我正在编写代码,直到现在我正在使用这样的结构:

struct s{
  enum Types { zero = 0, one, two };
  unsigned int type;
  void* data;
} 

我需要一些通用的结构来存储来自不同类的数据,我想在std :: vector中使用它,这就是为什么我不能使用模板的原因.什么是更好的选择:工会或无效指针？

Void指针只分配我需要的空间,但是由于某些原因,c ++是强类型语言,并且我需要使用这些数据的地方不是c ++代码应该设计的方式.正如我所读到的,除非别无选择,否则不应使用void指针.

这个替代方案可能是工会.它们带有c ++,并为每个成员使用相同的内存空间,非常类似于void指针.然而,它们的价格是合理的 - 分配的空间是联合中最大元素的大小,在我看来,大小之间的差异很大.

这是相当风格和"正确的语言使用"问题,因为这两种方式完成了我需要做的事情,但我不能确定好的程式化的c ++代码是否可以为浪费的内存付出代价(尽管这些日子的内存不是很大)关心).

我有一个函数getData(void* data) 应该复制到数据一些内部计算值,例如int r = getRadius(); r应该被复制到数据,并且是从函数getData返回的这种方式,这是正确的方法吗？我尝试过,*(int*)data = r; 但我不确定这是一个最好的解决方案.

int main()  
{  
    int a;  
    void *p;  
    p = &a;  
    printf("%ld\n",(long)p);  
    p = p+1;  
    printf("%ld\n",(long)p);  
}  

在这个程序中,p+1只是将p的值递增1.我知道void pointer arithmetic是不可能的C,所以GCC隐式地这样做.如果是的话,那就是它char pointer.另外,dereferencing如果void指针隐式执行指针运算,为什么不可能使用void指针.

简而言之,我创建了多个类来表示来自不同设备(实际上是摄像机)的数据.它们在引擎盖下都有不同的行为,但是交互的构建与外部完全相同.我正在尝试编写一个实用程序函数,可以使用任何一个类,或者可能是我编写的任何类,只要交互是相同的.我对C++很陌生,所以如果我的术语不完全正确,请耐心等待.

所以我要说每个相机都有这些定义.

class CamDataA
{
int getImageStart() {return ptrToStart;)
    int getImageSize() {return imageSizeVariable;)
}; 

class CamDataB
{
int getImageStart() {return ptrToStart;)
    int getImageSize() {return width*height*channels;)
}; 

我希望有另一个单独的类可以与任何一个类互换

class imageUtils
{
    //constructors/destructors

    int reportSize( void* camData)
    {
        cout << camData->getImageSize();
    }

}; 

但编译时得到的错误是:

error: ‘void*’ is not a pointer-to-object type

这甚至可能吗？

#include <stdio.h>
#include <string.h>

main()
{
    int an_int;
void *void_pointer = &an_int;
double *double_ptr = void_pointer;
*double_ptr = 10;

printf("%d", sizeof(*double_ptr));

}

这个程序的输出是8.这是
怎么回事？
我的意思是double_ptr指向4字节内存,但仍然输出为8.
*其他4个字节来自哪里？该程序应该崩溃,因为没有分配其他4个字节.*
请解释一下？

我正在尝试将C++类(例如class foo)与C 接口.到目前为止,我所做的是定义一个C结构,它包含一个不透明的指针成员变量(即void*),指向相关的C++ foo对象.

struct C_foo {
  void *foo_obj;
};

我定义了一个alloc()C接口函数来分配类型的对象C_foo:

struct C_foo* alloc(/* input */) {
  struct C_foo *out = new struct C_foo;
  out->foo_obj      = new foo(/* input */);

  return out;
};

我现在要做的是创建一个dealloc()C接口函数,该函数将正确释放C_foo先前分配的类型的对象,如上alloc()所示:

void dealloc(struct C_foo *obj) {
  /* ??? */
}

我知道显式删除void*指针(即delete obj->foo_obj;)会导致未定义的行为(§5.3.5/ 1 [expr.delete]):

该delete-expression的结果的类型为void[81].

[81]这意味着无法使用类型指针删除对象, 因为它不是对象类型.void* void

题: …

如果我有

void *temp = malloc(128);
memset(temp, 0 , 128);  

我想单独读取第一个字节，这是我在做什么。

char a[2];
strncpy(a, (char*)temp, 1);
int p = a[0];
//p will be zero in this case

Q1。我敢肯定，有一种更优雅的方法可以达到相同目的。如果是这样，那会是什么？

Q2。有没有办法我可以单独更改单个字节的值？

假设我希望第一个字节的值等于int值48（即00110000），我该怎么做？我写的没有任何进展。

我写了这个memcpy函数,但我仍然需要禁用规则11.5和11.8.是否有完整的MISRA:2012兼容解决方案？

#pragma cstat_suppress="MISRAC2012-Rule-21.6" // Uses of stdio.h were found.
#include <stdio.h>

#include <stdint.h>
#include <string.h>
#include <stdlib.h>

extern int main(void);

static int_least8_t _memcpy(void *dst, const void *src, const size_t length)
{
    #pragma cstat_disable="MISRAC2012-Rule-11.5" // A conversion from a pointer to void into a pointer to object was found.
    int_least8_t* destination = (int_least8_t*)dst;
    #pragma cstat_disable="MISRAC2012-Rule-11.8" // A cast that removes a const or volatile qualification was found.
    const int_least8_t* source = (int_least8_t*)src;
    #pragma cstat_restore="MISRAC2012-Rule-11.5","MISRAC2012-Rule-11.8"

    for (size_t i = 0; …