C++ wrapper for an array of pointers returned from a C function

Question

I'm adding a C++ front-end to a C library. One function in this library calls back to a handler with an array and an integer with the size of the array. Therefore you must provide a C function,

int handler(int argc, sometype **argv);

Now, I'd like to allow the C++ calling code to provide a more C++ish handler function, something like,

int handler(std::vector<sometype*> args);

Changing the handler type isn't hard, I just have to provide my own handler which then calls the user-provided handler. So I need to create an std::vector and copy the contents of argv into it.

However, I don't really want to copy the entire list of pointers if possible. Unfortunately I think it's not possible to tell std::vector to use an already-allocated block of memory for its internal array, and moreover the array is static, and should be considered const.

Is there some STL type similar to std::vector that can be used to wrap pre-allocated C-style arrays with a more friendly interface? It should support size query and iteration, similar to std::vector.

Thanks.

An intrusive array reference wrapper? Not in the standard library, but easy enough to write yourself... people have been asking for a string_ref type for ages... — Kerrek SB
– Kerrek SB, Commented Sep 6, 2012 at 16:23
There's no standard container that will do this for you, as far as I'm aware. Perhaps Boost might help, but I'm not familiar with it. Writing your own container shouldn't be too hard, however! I will note that std::vector is not an appropriate concept for wrapping a fixed-length array; vectors may grow and shrink which an array cannot. — Rook
– Rook, Commented Sep 6, 2012 at 16:25
+1 encapsulating array primitve type for a more encapsulating, maybe object oriented collection — umlcat
– umlcat, Commented Sep 6, 2012 at 16:31
@Rook: yeah, std::array is probably closer to what I'm looking for. — Steve
– Steve, Commented Sep 6, 2012 at 16:44

Fox Cutter · Accepted Answer · 2012-09-06 16:39:31Z

1

Have you thought about making your function take a pair of iterators instead of a container? You would have to make it a template function, so I can understand why that may not work as well as you would like, but it would let you pass in the array.

template<typename I>
int handler(I begin, I end);

handler(argv, &argv[argc]);

It's still not a perfect solution, but it would be a touch more generic and allow for you to use the preexisting array.

answered Sep 6, 2012 at 16:39

Fox Cutter

6554 silver badges11 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Mooing Duck · Accepted Answer · 2012-09-06 16:55:04Z

1

I'm not certain what you're asking, but If I was given this function prototype

int handler(int argc, const sometype *const *argv);

Here's make a C++ wrapper:

int handler(const std::vector<sometype*>& arg) 
{return handler(arg.size(), &arg[0]);} //no copies

template<class const_iterator>
int handler(const_iterator begin, const_iterator end) //can pass any structure
{return handler(std::distance(begin, end), &*begin);} //no copies

Here's how I would implement this API in C++:

int handler(int argc, const sometype *const*argv) {
    const std::vector<const sometype*> arg(argv, argv+argc); //this will copy the pointers
    //stuff
}

Unfortunately, there's no way to get an existing array into a vector, but is copying a few pointers really slow enough to care about?

Proof of compilation: http://ideone.com/BkSVd

edited Sep 6, 2012 at 16:55

answered Sep 6, 2012 at 16:41

Mooing Duck

67.6k19 gold badges107 silver badges169 bronze badges

2 Comments

Steve Over a year ago

Right, but that copies my immutable data into a mutable container. It works, but I'm wondering if there's something that doesn't require copying.

Mooing Duck Over a year ago

wait, which data is supposed to be immutable? In that function signature, everything is mutable, there's no const anywhere. Oh! I see it. I added const to the signatures, problem solved.

im so confused · Accepted Answer · 2012-09-06 16:24:55Z

0

Well, I'm sure if you know about ::vector, you've looked into ::array?

http://www.cplusplus.com/reference/stl/array/

However, the main problem - overlaying objects onto existing memory - reminds me of simple packet sniffers: create the object structure, then overlay it by moving its reference over the known data. I'm not sure if you can do this in your problem, but that'd be the first avenue I'd consider.

Note: I don't know exactly how a std::array is laid out so obviously that would be difficult to implement :/

answered Sep 6, 2012 at 16:24

im so confused

2,1211 gold badge17 silver badges25 bronze badges

9 Comments

Rook Over a year ago

Both std::array and std::vector are laid out as a contiguous slab of memory; getting the address of the first element of a vector by doing a &myvector[0] will get you a pointer you can use as a plain C array. This means you can memcpy into and out of appropriately sized vectors and array objects.

Fox Cutter Over a year ago

The biggest downside to std::array is that you need to pass the size as part of the template parameters, makes it less then ideal for a variable sized array.

im so confused Over a year ago

@FoxCutter yes, you're right. I guess my assumption that as he was dealing with a C array was that the size requirement would remain the same, which is obviously false. Maybe some more info on the issue could clarify that. Apart from that, would my proposed solution work to simply overlay the std::array? (and given Rook's info, wouldn't a vector overlay also work?)

Fox Cutter Over a year ago

@AkshayaAnnavajhala Yes, other then the size thing it would work just fine. I often use std::vector in place of doing an array new, just keeps the code tidy, it's easy to pass to C code and API, and in release build the iterators are just pointers, so it's fast.

Steve Over a year ago

Yeah, std::array is probably exactly what I'm looking for, but is it possible to tell it to use my array directly rather than allocating it itself? Also, is there such thing as an immutable std::array? (Some kind of const variation?)

|

umlcat · Accepted Answer · 2012-09-06 16:45:10Z

0

What type of data is going to be referenced by those pointer elements ?

Who is the owner of those pointer elements, I mean, are those elements just referenced by the collection / data structure, or is that collection in charge of allocating, deallocating those items ?

Are those items equal type or equal size ?

For example, array of characters of different size, or objects that may be different base class, but descend from a common ancestor.

All these topics maybe considered to decide which library, object oriented or not, and which data structure or collection to use.

Seems std and Boost should be first option to lookup first. But, sometimes, you may have to built your own collection.

Your library seems to require more like an indexable List concept than an Array, altought, sometimes are interchangable.

Cheers.

answered Sep 6, 2012 at 16:45

umlcat

4,1513 gold badges21 silver badges31 bronze badges

2 Comments

Steve Over a year ago

Sorry for the ambiguity. The array provided to the handler is considered "not to be touched", and "size" does not change. I just want to wrap it up so that the C++ user sees an STL-like interface.

umlcat Over a year ago

@Steve It makes sense since its a parameter collection, more than indexable read-only list

Collectives™ on Stack Overflow

C++ wrapper for an array of pointers returned from a C function

4 Answers 4

Comments

2 Comments

9 Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

2 Comments

9 Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related