我正在尝试使用 void 指针缓冲区创建通用循环缓冲区,但遇到了一些我不明白的问题。
如果我对缓冲区使用双指针,则循环缓冲区的行为符合预期(请参见下面的测试 1),但如果我使用空指针,则会得到错误的行为(请参见测试 2),尽管所有空指针都已转换到双指针。我的选角有什么问题吗?
还有一个问题:在circular_buffer_write_chunk
中,我使用双指针来传递数据。我需要将它作为 void 指针传递,以使其通用。然后,我必须在函数中将其动态转换为缓冲区的类型(可以是 double 或 int),以便使指针算术正常工作。我怎样才能做到这一点?如何获取指向缓冲区的指针的类型,然后将数据指针转换为该类型?
欢迎任何意见或建议。
test1 使用缓冲区作为双指针运行 circular_buffer_test()
*** circular_buffer test***
capacity: 12
Write 5 values
cb[0]=0.000000
cb[1]=1.000000
cb[2]=2.000000
cb[3]=3.000000
cb[4]=4.000000
cb[5]=0.000000
cb[6]=0.000000
cb[7]=0.000000
cb[8]=0.000000
cb[9]=0.000000
cb[10]=0.000000
cb[11]=0.000000
Write 10 values
cb[0]=12.000000
cb[1]=13.000000
cb[2]=14.000000
cb[3]=3.000000
cb[4]=4.000000
cb[5]=5.000000
cb[6]=6.000000
cb[7]=7.000000
cb[8]=8.000000
cb[9]=9.000000
cb[10]=10.000000
cb[11]=11.000000
Test done
test2 使用 buffer 作为 void 指针运行 circular_buffer_test()
。为什么会不一样?
*** circular_buffer test***
capacity: 12
Write 5 values
cb[0]=0.000000
cb[1]=1.000000
cb[2]=2.000000
cb[3]=3.000000
cb[4]=4.000000
cb[5]=0.000000
cb[6]=0.000000
cb[7]=0.000000
cb[8]=0.000000
cb[9]=0.000000
cb[10]=0.000000
cb[11]=0.000000
Write 10 values
cb[0]=12.000000
cb[1]=13.000000
cb[2]=14.000000
cb[3]=0.000000 // ?
cb[4]=0.000000 // ?
cb[5]=0.000000 // ?
cb[6]=0.000000 // ?
cb[7]=0.000000 // ?
cb[8]=0.000000 // ?
cb[9]=0.000000 // ?
cb[10]=0.000000 // ?
cb[11]=0.000000 // ?
Test done
circular_buffer.c
#include "circular_buffer.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
typedef struct
{
double *buffer;
double *buffer_end;
unsigned int capacity;
double *read_ptr;
double *write_ptr;
unsigned int count;
} circular_buffer;
/*
// Why doesn't this behave like with double pointer, since it's casted in circular_buffer_init_double?
typedef struct
{
void *buffer;
void *buffer_end;
unsigned int capacity;
void *read_ptr;
void *write_ptr;
unsigned int count;
} circular_buffer;
*/
void circular_buffer_init_double(circular_buffer *cb, unsigned int capacity)
{
cb->buffer = (double*) malloc(sizeof(double) * capacity);
cb->buffer_end = (double*) (cb->buffer + capacity);
cb->capacity = capacity;
cb->read_ptr = (double*) (cb->buffer);
cb->write_ptr = (double*) (cb->buffer);
cb->count = 0;
}
void circular_buffer_destroy(circular_buffer *cb){
free(cb->buffer);
cb->buffer = NULL;
}
int circular_buffer_is_full(circular_buffer *cb) {
return cb->count == cb->capacity;
}
int circular_buffer_is_empty(circular_buffer *cb) {
return cb->count == 0;
}
unsigned int circular_buffer_write_chunk(circular_buffer* cb, double *data, unsigned int type_size,
unsigned int num_elements){
if( num_elements > cb->capacity ) return 0;
if( cb->write_ptr + num_elements > cb->buffer_end ){
unsigned int write_ptr_to_buffer_end = cb->buffer_end - cb->write_ptr;
unsigned int write_ptr_position = cb->write_ptr - cb->buffer;
memcpy( cb->write_ptr, data, write_ptr_to_buffer_end * type_size );
memcpy( cb->buffer, data + write_ptr_to_buffer_end,
( num_elements - write_ptr_to_buffer_end) * type_size );
cb->write_ptr = cb->buffer + num_elements - write_ptr_to_buffer_end;
}
else{
memcpy( cb->write_ptr, data, type_size * num_elements );
cb->write_ptr += num_elements;
if( cb->write_ptr == cb->buffer_end ){
cb->write_ptr = cb->buffer;
}
}
if( circular_buffer_is_full(cb) ) cb->read_ptr = cb->write_ptr;
cb->count = cb->count + num_elements > cb->capacity ? cb->capacity : cb->count + num_elements;
return num_elements;
}
void circular_buffer_test(){
fprintf(stdout, "*** circular_buffer test***\n");
circular_buffer *cb = malloc(sizeof(circular_buffer));
circular_buffer_init_double(cb, 12);
fprintf(stdout, "capacity: %d\n", cb->capacity);
int i;
double *w1 = malloc(sizeof(double) * 5);
for(i=0; i<5; i++) w1[i] = (double) i;
fprintf(stdout, "\nWrite 5 values\n");
circular_buffer_write_chunk(cb, w1, sizeof(double), 5);
for(i=0; i<12; i++) fprintf(stdout, "cb[%d]=%f\n", i, ((double *)cb->buffer)[i]);
fprintf(stdout, "\nWrite 10 values\n");
double *w2 = malloc(sizeof(double) * 10);
for(i=5; i<15; i++) w2[i-5] = (double) i;
circular_buffer_write_chunk(cb, w2, sizeof(double), 10);
for(i=0; i<12; i++) fprintf(stdout, "cb[%d]=%f\n", i, ((double *)cb->buffer)[i]);
free(w1);
free(w2);
circular_buffer_destroy(cb);
fprintf(stdout, "Test done\n");
}
最佳答案
C 中不允许使用 void *
进行指针算术:
(double*) (cb->buffer + capacity);
gcc
添加了 void *
的指针算术作为扩展,将 void
的大小考虑为 1
.
buffer
是否为void *
与gcc
或double *
cb->的结果缓冲区+容量
会有所不同。使用:
((double*) cb->buffer + capacity);
如果buffer
是void *
。
关于c - 空指针转换为其他指针类型 T 的行为与 T 不同,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/24219960/