How should I replace vector::const_iterator in an API? The 2019 Stack Overflow Developer...
Did the new image of black hole confirm the general theory of relativity?
Do warforged have souls?
Why not take a picture of a closer black hole?
Are spiders unable to hurt humans, especially very small spiders?
What was the last x86 CPU that did not have the x87 floating-point unit built in?
In horse breeding, what is the female equivalent of putting a horse out "to stud"?
Match Roman Numerals
Why did all the guest students take carriages to the Yule Ball?
Take groceries in checked luggage
What aspect of planet Earth must be changed to prevent the industrial revolution?
Can the DM override racial traits?
Can undead you have reanimated wait inside a portable hole?
Does the AirPods case need to be around while listening via an iOS Device?
First use of “packing” as in carrying a gun
What can I do if neighbor is blocking my solar panels intentionally?
How is simplicity better than precision and clarity in prose?
Python - Fishing Simulator
How to copy the contents of all files with a certain name into a new file?
Why can't devices on different VLANs, but on the same subnet, communicate?
How to politely respond to generic emails requesting a PhD/job in my lab? Without wasting too much time
How does this infinite series simplify to an integral?
Sort list of array linked objects by keys and values
A pet rabbit called Belle
Simulating Exploding Dice
How should I replace vector::const_iterator in an API?
The 2019 Stack Overflow Developer Survey Results Are In
Announcing the arrival of Valued Associate #679: Cesar Manara
Planned maintenance scheduled April 17/18, 2019 at 00:00UTC (8:00pm US/Eastern)
The Ask Question Wizard is Live!
Data science time! April 2019 and salary with experienceWhat is a “span” and when should I use one?Singleton: How should it be usedHow to find out if an item is present in a std::vector?How do I erase an element from std::vector<> by index?How to replace all occurrences of a character in string?How to convert vector to arrayHow to correctly implement custom iterators and const_iterators?Interface-based programming in C++ in combination with iterators. How too keep this simple?How to implement the factory method pattern in C++ correctlyHow to print out the contents of a vector?Vector, iterators and const_iterator
.everyoneloves__top-leaderboard:empty,.everyoneloves__mid-leaderboard:empty,.everyoneloves__bot-mid-leaderboard:empty{ height:90px;width:728px;box-sizing:border-box;
}
I've been given the task of polishing the interface of a codec library. We're using C++17, and I can only use the standard library (i.e. no Boost). Currently, there's a Decoder
class that looks roughly like this:
class Decoder : public Codec {
public:
struct Result {
vector<uint8_t>::const_iterator new_buffer_begin;
optional<Metadata> metadata;
optional<Packet> packet;
};
Result decode(vector<uint8_t>::const_iterator buffer_begin,
vector<uint8_t>::const_iterator buffer_end);
private:
// irrelevant details
};
The caller instantiates a Decoder
, then feeds a stream of data to the decoder by
Reading a chunk of data from a file (but there could be other sources in the future), and appending it to a
vector<uint8_t>
.Calling the
decode
function, passing the iterators for their vector.If the returned
Result
'snew_buffer_begin
is identical to thebuffer_begin
that was passed todecode
, that means there wasn't enough data in the buffer to decode anything, and the caller should go back to step 1. Otherwise, the caller consumes theMetadata
orPacket
object that was decoded, and goes back to step 2, usingnew_buffer_begin
for the next pass.
The things I dislike about this interface and need help improving:
Using
vector<uint8_t>::const_iterator
seems overly specific. Is there a more generic approach that doesn't force the caller to usevector
? I was considering just using C-style interface; auint8_t *
and a length. Is there a C++ alternative that's fairly generic?If there was enough data to decode something, only
metadata
orpacket
will have a value. I thinkstd::variant
or 2 callbacks (one for each type) would make this code more self-documenting. I'm not sure which is more idiomatic though. What are the pros and cons of each, and is there an even better approach?
c++ c++17 binary-data idiomatic
add a comment |
I've been given the task of polishing the interface of a codec library. We're using C++17, and I can only use the standard library (i.e. no Boost). Currently, there's a Decoder
class that looks roughly like this:
class Decoder : public Codec {
public:
struct Result {
vector<uint8_t>::const_iterator new_buffer_begin;
optional<Metadata> metadata;
optional<Packet> packet;
};
Result decode(vector<uint8_t>::const_iterator buffer_begin,
vector<uint8_t>::const_iterator buffer_end);
private:
// irrelevant details
};
The caller instantiates a Decoder
, then feeds a stream of data to the decoder by
Reading a chunk of data from a file (but there could be other sources in the future), and appending it to a
vector<uint8_t>
.Calling the
decode
function, passing the iterators for their vector.If the returned
Result
'snew_buffer_begin
is identical to thebuffer_begin
that was passed todecode
, that means there wasn't enough data in the buffer to decode anything, and the caller should go back to step 1. Otherwise, the caller consumes theMetadata
orPacket
object that was decoded, and goes back to step 2, usingnew_buffer_begin
for the next pass.
The things I dislike about this interface and need help improving:
Using
vector<uint8_t>::const_iterator
seems overly specific. Is there a more generic approach that doesn't force the caller to usevector
? I was considering just using C-style interface; auint8_t *
and a length. Is there a C++ alternative that's fairly generic?If there was enough data to decode something, only
metadata
orpacket
will have a value. I thinkstd::variant
or 2 callbacks (one for each type) would make this code more self-documenting. I'm not sure which is more idiomatic though. What are the pros and cons of each, and is there an even better approach?
c++ c++17 binary-data idiomatic
Is there a C++ alternative that's fairly generic?
Templates.
– tkausl
1 hour ago
typedef vector<uint8_t>::const_iterator it_t;
orusing it_t= vector<uint8_t>::const_iterator;
will make it cleaner.
– Mirko
1 hour ago
1
I like the callback approach, passing a consumer object with a callback for each kind of result produced. When the method return you give the guaranty that at most one callback has been called. But you could also have an async variant. The API could evolve by adding more callback to the consumer. std::variant is also good but may require the user to check which one is available (doesn't really change from two optionals).
– semako
1 hour ago
add a comment |
I've been given the task of polishing the interface of a codec library. We're using C++17, and I can only use the standard library (i.e. no Boost). Currently, there's a Decoder
class that looks roughly like this:
class Decoder : public Codec {
public:
struct Result {
vector<uint8_t>::const_iterator new_buffer_begin;
optional<Metadata> metadata;
optional<Packet> packet;
};
Result decode(vector<uint8_t>::const_iterator buffer_begin,
vector<uint8_t>::const_iterator buffer_end);
private:
// irrelevant details
};
The caller instantiates a Decoder
, then feeds a stream of data to the decoder by
Reading a chunk of data from a file (but there could be other sources in the future), and appending it to a
vector<uint8_t>
.Calling the
decode
function, passing the iterators for their vector.If the returned
Result
'snew_buffer_begin
is identical to thebuffer_begin
that was passed todecode
, that means there wasn't enough data in the buffer to decode anything, and the caller should go back to step 1. Otherwise, the caller consumes theMetadata
orPacket
object that was decoded, and goes back to step 2, usingnew_buffer_begin
for the next pass.
The things I dislike about this interface and need help improving:
Using
vector<uint8_t>::const_iterator
seems overly specific. Is there a more generic approach that doesn't force the caller to usevector
? I was considering just using C-style interface; auint8_t *
and a length. Is there a C++ alternative that's fairly generic?If there was enough data to decode something, only
metadata
orpacket
will have a value. I thinkstd::variant
or 2 callbacks (one for each type) would make this code more self-documenting. I'm not sure which is more idiomatic though. What are the pros and cons of each, and is there an even better approach?
c++ c++17 binary-data idiomatic
I've been given the task of polishing the interface of a codec library. We're using C++17, and I can only use the standard library (i.e. no Boost). Currently, there's a Decoder
class that looks roughly like this:
class Decoder : public Codec {
public:
struct Result {
vector<uint8_t>::const_iterator new_buffer_begin;
optional<Metadata> metadata;
optional<Packet> packet;
};
Result decode(vector<uint8_t>::const_iterator buffer_begin,
vector<uint8_t>::const_iterator buffer_end);
private:
// irrelevant details
};
The caller instantiates a Decoder
, then feeds a stream of data to the decoder by
Reading a chunk of data from a file (but there could be other sources in the future), and appending it to a
vector<uint8_t>
.Calling the
decode
function, passing the iterators for their vector.If the returned
Result
'snew_buffer_begin
is identical to thebuffer_begin
that was passed todecode
, that means there wasn't enough data in the buffer to decode anything, and the caller should go back to step 1. Otherwise, the caller consumes theMetadata
orPacket
object that was decoded, and goes back to step 2, usingnew_buffer_begin
for the next pass.
The things I dislike about this interface and need help improving:
Using
vector<uint8_t>::const_iterator
seems overly specific. Is there a more generic approach that doesn't force the caller to usevector
? I was considering just using C-style interface; auint8_t *
and a length. Is there a C++ alternative that's fairly generic?If there was enough data to decode something, only
metadata
orpacket
will have a value. I thinkstd::variant
or 2 callbacks (one for each type) would make this code more self-documenting. I'm not sure which is more idiomatic though. What are the pros and cons of each, and is there an even better approach?
c++ c++17 binary-data idiomatic
c++ c++17 binary-data idiomatic
asked 1 hour ago
splicersplicer
3,86243545
3,86243545
Is there a C++ alternative that's fairly generic?
Templates.
– tkausl
1 hour ago
typedef vector<uint8_t>::const_iterator it_t;
orusing it_t= vector<uint8_t>::const_iterator;
will make it cleaner.
– Mirko
1 hour ago
1
I like the callback approach, passing a consumer object with a callback for each kind of result produced. When the method return you give the guaranty that at most one callback has been called. But you could also have an async variant. The API could evolve by adding more callback to the consumer. std::variant is also good but may require the user to check which one is available (doesn't really change from two optionals).
– semako
1 hour ago
add a comment |
Is there a C++ alternative that's fairly generic?
Templates.
– tkausl
1 hour ago
typedef vector<uint8_t>::const_iterator it_t;
orusing it_t= vector<uint8_t>::const_iterator;
will make it cleaner.
– Mirko
1 hour ago
1
I like the callback approach, passing a consumer object with a callback for each kind of result produced. When the method return you give the guaranty that at most one callback has been called. But you could also have an async variant. The API could evolve by adding more callback to the consumer. std::variant is also good but may require the user to check which one is available (doesn't really change from two optionals).
– semako
1 hour ago
Is there a C++ alternative that's fairly generic?
Templates.– tkausl
1 hour ago
Is there a C++ alternative that's fairly generic?
Templates.– tkausl
1 hour ago
typedef vector<uint8_t>::const_iterator it_t;
or using it_t= vector<uint8_t>::const_iterator;
will make it cleaner.– Mirko
1 hour ago
typedef vector<uint8_t>::const_iterator it_t;
or using it_t= vector<uint8_t>::const_iterator;
will make it cleaner.– Mirko
1 hour ago
1
1
I like the callback approach, passing a consumer object with a callback for each kind of result produced. When the method return you give the guaranty that at most one callback has been called. But you could also have an async variant. The API could evolve by adding more callback to the consumer. std::variant is also good but may require the user to check which one is available (doesn't really change from two optionals).
– semako
1 hour ago
I like the callback approach, passing a consumer object with a callback for each kind of result produced. When the method return you give the guaranty that at most one callback has been called. But you could also have an async variant. The API could evolve by adding more callback to the consumer. std::variant is also good but may require the user to check which one is available (doesn't really change from two optionals).
– semako
1 hour ago
add a comment |
3 Answers
3
active
oldest
votes
I agree that mandating vector
is inappropriate, and applaud your attempts to make the interface more useful.
If decode
expects a contiguous sequence of uint8_t
, the tried-and-tested (and most flexible) solution is just to take a const uint8_t*
and a std::size_t
(or alternatively two pointers, but pointer and length is more idiomatic).
From C++20 you can do this with one argument of type std::span<const uint8_t>
. Or going back to pointers, if you really want to use modern library tools for the sake of it, you can confuse people with std::experimental::observer_ptr
.
You may also consider making decode
a template that accepts any iterator pair, and (if contiguity is needed) mandates, even if only by documentation, that the iterators reflect a contiguous sequence. But making everything a template isn't always what you want, and it isn't always useful.
add a comment |
In addition to @Justin's valid suggestion of spans:
- You might also want to consider using
std::byte
instead ofuint8_t
, so:
Result decode(std::span<const std::byte> buffer);
If you want to support decoding from containers other than raw memory, use arbitrary iterators (in C++17 and earlier) or possibly ranges (in C++20). The iterator version:
template <typename InputIt>
Result decode(InputIt start, InputIt end) { /* etc. */ }
It's fishy that a
Decoder
inherits from aCodec
rather than the other way around.- The question of whether callbacks are a good choice or not is something that's difficult (for me) to answer without seeing the code. But do indeed use an
std::variant
to express the fact you have either a Packet or Metadata; you could also "combine" both your options if instead of callbacks you use variants'std::visit
.
Decoder and another class, Encoder, inherit from Codec because Codec provides the majority of maintained state and a bunch of shared logic. Unfortunately, I'm not allowed to share the code; just the interface. Your suggestion of usingstd::visit
looks promising. Thanks!
– splicer
1 hour ago
@splicer: In that case, consider either renaming Encoder or perhaps taking some functionality out into a namespace.
– einpoklum
1 hour ago
add a comment |
C++20 will have std::span
, which does what you want:
Result decode(std::span<uint8_t const> buffer);
std::span<T>
is semantically equivalent to a T* buffer, size_t size
.
In C++17, there are some implementations of a span
type which are equivalent to std::span
, such as the GSL's gsl::span
. See What is a "span" and when should I use one? .
If you can't use any external libraries, consider writing your own span
type, else
uint8_t const* buffer_begin, uint8_t const* buffer_end
can work.
add a comment |
Your Answer
StackExchange.ifUsing("editor", function () {
StackExchange.using("externalEditor", function () {
StackExchange.using("snippets", function () {
StackExchange.snippets.init();
});
});
}, "code-snippets");
StackExchange.ready(function() {
var channelOptions = {
tags: "".split(" "),
id: "1"
};
initTagRenderer("".split(" "), "".split(" "), channelOptions);
StackExchange.using("externalEditor", function() {
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled) {
StackExchange.using("snippets", function() {
createEditor();
});
}
else {
createEditor();
}
});
function createEditor() {
StackExchange.prepareEditor({
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: true,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: 10,
bindNavPrevention: true,
postfix: "",
imageUploader: {
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
},
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
});
}
});
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f55670315%2fhow-should-i-replace-vectoruint8-tconst-iterator-in-an-api%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
3 Answers
3
active
oldest
votes
3 Answers
3
active
oldest
votes
active
oldest
votes
active
oldest
votes
I agree that mandating vector
is inappropriate, and applaud your attempts to make the interface more useful.
If decode
expects a contiguous sequence of uint8_t
, the tried-and-tested (and most flexible) solution is just to take a const uint8_t*
and a std::size_t
(or alternatively two pointers, but pointer and length is more idiomatic).
From C++20 you can do this with one argument of type std::span<const uint8_t>
. Or going back to pointers, if you really want to use modern library tools for the sake of it, you can confuse people with std::experimental::observer_ptr
.
You may also consider making decode
a template that accepts any iterator pair, and (if contiguity is needed) mandates, even if only by documentation, that the iterators reflect a contiguous sequence. But making everything a template isn't always what you want, and it isn't always useful.
add a comment |
I agree that mandating vector
is inappropriate, and applaud your attempts to make the interface more useful.
If decode
expects a contiguous sequence of uint8_t
, the tried-and-tested (and most flexible) solution is just to take a const uint8_t*
and a std::size_t
(or alternatively two pointers, but pointer and length is more idiomatic).
From C++20 you can do this with one argument of type std::span<const uint8_t>
. Or going back to pointers, if you really want to use modern library tools for the sake of it, you can confuse people with std::experimental::observer_ptr
.
You may also consider making decode
a template that accepts any iterator pair, and (if contiguity is needed) mandates, even if only by documentation, that the iterators reflect a contiguous sequence. But making everything a template isn't always what you want, and it isn't always useful.
add a comment |
I agree that mandating vector
is inappropriate, and applaud your attempts to make the interface more useful.
If decode
expects a contiguous sequence of uint8_t
, the tried-and-tested (and most flexible) solution is just to take a const uint8_t*
and a std::size_t
(or alternatively two pointers, but pointer and length is more idiomatic).
From C++20 you can do this with one argument of type std::span<const uint8_t>
. Or going back to pointers, if you really want to use modern library tools for the sake of it, you can confuse people with std::experimental::observer_ptr
.
You may also consider making decode
a template that accepts any iterator pair, and (if contiguity is needed) mandates, even if only by documentation, that the iterators reflect a contiguous sequence. But making everything a template isn't always what you want, and it isn't always useful.
I agree that mandating vector
is inappropriate, and applaud your attempts to make the interface more useful.
If decode
expects a contiguous sequence of uint8_t
, the tried-and-tested (and most flexible) solution is just to take a const uint8_t*
and a std::size_t
(or alternatively two pointers, but pointer and length is more idiomatic).
From C++20 you can do this with one argument of type std::span<const uint8_t>
. Or going back to pointers, if you really want to use modern library tools for the sake of it, you can confuse people with std::experimental::observer_ptr
.
You may also consider making decode
a template that accepts any iterator pair, and (if contiguity is needed) mandates, even if only by documentation, that the iterators reflect a contiguous sequence. But making everything a template isn't always what you want, and it isn't always useful.
edited 1 hour ago
answered 1 hour ago
Lightness Races in OrbitLightness Races in Orbit
295k55479816
295k55479816
add a comment |
add a comment |
In addition to @Justin's valid suggestion of spans:
- You might also want to consider using
std::byte
instead ofuint8_t
, so:
Result decode(std::span<const std::byte> buffer);
If you want to support decoding from containers other than raw memory, use arbitrary iterators (in C++17 and earlier) or possibly ranges (in C++20). The iterator version:
template <typename InputIt>
Result decode(InputIt start, InputIt end) { /* etc. */ }
It's fishy that a
Decoder
inherits from aCodec
rather than the other way around.- The question of whether callbacks are a good choice or not is something that's difficult (for me) to answer without seeing the code. But do indeed use an
std::variant
to express the fact you have either a Packet or Metadata; you could also "combine" both your options if instead of callbacks you use variants'std::visit
.
Decoder and another class, Encoder, inherit from Codec because Codec provides the majority of maintained state and a bunch of shared logic. Unfortunately, I'm not allowed to share the code; just the interface. Your suggestion of usingstd::visit
looks promising. Thanks!
– splicer
1 hour ago
@splicer: In that case, consider either renaming Encoder or perhaps taking some functionality out into a namespace.
– einpoklum
1 hour ago
add a comment |
In addition to @Justin's valid suggestion of spans:
- You might also want to consider using
std::byte
instead ofuint8_t
, so:
Result decode(std::span<const std::byte> buffer);
If you want to support decoding from containers other than raw memory, use arbitrary iterators (in C++17 and earlier) or possibly ranges (in C++20). The iterator version:
template <typename InputIt>
Result decode(InputIt start, InputIt end) { /* etc. */ }
It's fishy that a
Decoder
inherits from aCodec
rather than the other way around.- The question of whether callbacks are a good choice or not is something that's difficult (for me) to answer without seeing the code. But do indeed use an
std::variant
to express the fact you have either a Packet or Metadata; you could also "combine" both your options if instead of callbacks you use variants'std::visit
.
Decoder and another class, Encoder, inherit from Codec because Codec provides the majority of maintained state and a bunch of shared logic. Unfortunately, I'm not allowed to share the code; just the interface. Your suggestion of usingstd::visit
looks promising. Thanks!
– splicer
1 hour ago
@splicer: In that case, consider either renaming Encoder or perhaps taking some functionality out into a namespace.
– einpoklum
1 hour ago
add a comment |
In addition to @Justin's valid suggestion of spans:
- You might also want to consider using
std::byte
instead ofuint8_t
, so:
Result decode(std::span<const std::byte> buffer);
If you want to support decoding from containers other than raw memory, use arbitrary iterators (in C++17 and earlier) or possibly ranges (in C++20). The iterator version:
template <typename InputIt>
Result decode(InputIt start, InputIt end) { /* etc. */ }
It's fishy that a
Decoder
inherits from aCodec
rather than the other way around.- The question of whether callbacks are a good choice or not is something that's difficult (for me) to answer without seeing the code. But do indeed use an
std::variant
to express the fact you have either a Packet or Metadata; you could also "combine" both your options if instead of callbacks you use variants'std::visit
.
In addition to @Justin's valid suggestion of spans:
- You might also want to consider using
std::byte
instead ofuint8_t
, so:
Result decode(std::span<const std::byte> buffer);
If you want to support decoding from containers other than raw memory, use arbitrary iterators (in C++17 and earlier) or possibly ranges (in C++20). The iterator version:
template <typename InputIt>
Result decode(InputIt start, InputIt end) { /* etc. */ }
It's fishy that a
Decoder
inherits from aCodec
rather than the other way around.- The question of whether callbacks are a good choice or not is something that's difficult (for me) to answer without seeing the code. But do indeed use an
std::variant
to express the fact you have either a Packet or Metadata; you could also "combine" both your options if instead of callbacks you use variants'std::visit
.
edited 1 hour ago
answered 1 hour ago
einpoklumeinpoklum
37.3k28134263
37.3k28134263
Decoder and another class, Encoder, inherit from Codec because Codec provides the majority of maintained state and a bunch of shared logic. Unfortunately, I'm not allowed to share the code; just the interface. Your suggestion of usingstd::visit
looks promising. Thanks!
– splicer
1 hour ago
@splicer: In that case, consider either renaming Encoder or perhaps taking some functionality out into a namespace.
– einpoklum
1 hour ago
add a comment |
Decoder and another class, Encoder, inherit from Codec because Codec provides the majority of maintained state and a bunch of shared logic. Unfortunately, I'm not allowed to share the code; just the interface. Your suggestion of usingstd::visit
looks promising. Thanks!
– splicer
1 hour ago
@splicer: In that case, consider either renaming Encoder or perhaps taking some functionality out into a namespace.
– einpoklum
1 hour ago
Decoder and another class, Encoder, inherit from Codec because Codec provides the majority of maintained state and a bunch of shared logic. Unfortunately, I'm not allowed to share the code; just the interface. Your suggestion of using
std::visit
looks promising. Thanks!– splicer
1 hour ago
Decoder and another class, Encoder, inherit from Codec because Codec provides the majority of maintained state and a bunch of shared logic. Unfortunately, I'm not allowed to share the code; just the interface. Your suggestion of using
std::visit
looks promising. Thanks!– splicer
1 hour ago
@splicer: In that case, consider either renaming Encoder or perhaps taking some functionality out into a namespace.
– einpoklum
1 hour ago
@splicer: In that case, consider either renaming Encoder or perhaps taking some functionality out into a namespace.
– einpoklum
1 hour ago
add a comment |
C++20 will have std::span
, which does what you want:
Result decode(std::span<uint8_t const> buffer);
std::span<T>
is semantically equivalent to a T* buffer, size_t size
.
In C++17, there are some implementations of a span
type which are equivalent to std::span
, such as the GSL's gsl::span
. See What is a "span" and when should I use one? .
If you can't use any external libraries, consider writing your own span
type, else
uint8_t const* buffer_begin, uint8_t const* buffer_end
can work.
add a comment |
C++20 will have std::span
, which does what you want:
Result decode(std::span<uint8_t const> buffer);
std::span<T>
is semantically equivalent to a T* buffer, size_t size
.
In C++17, there are some implementations of a span
type which are equivalent to std::span
, such as the GSL's gsl::span
. See What is a "span" and when should I use one? .
If you can't use any external libraries, consider writing your own span
type, else
uint8_t const* buffer_begin, uint8_t const* buffer_end
can work.
add a comment |
C++20 will have std::span
, which does what you want:
Result decode(std::span<uint8_t const> buffer);
std::span<T>
is semantically equivalent to a T* buffer, size_t size
.
In C++17, there are some implementations of a span
type which are equivalent to std::span
, such as the GSL's gsl::span
. See What is a "span" and when should I use one? .
If you can't use any external libraries, consider writing your own span
type, else
uint8_t const* buffer_begin, uint8_t const* buffer_end
can work.
C++20 will have std::span
, which does what you want:
Result decode(std::span<uint8_t const> buffer);
std::span<T>
is semantically equivalent to a T* buffer, size_t size
.
In C++17, there are some implementations of a span
type which are equivalent to std::span
, such as the GSL's gsl::span
. See What is a "span" and when should I use one? .
If you can't use any external libraries, consider writing your own span
type, else
uint8_t const* buffer_begin, uint8_t const* buffer_end
can work.
answered 1 hour ago
JustinJustin
13.8k95899
13.8k95899
add a comment |
add a comment |
Thanks for contributing an answer to Stack Overflow!
- Please be sure to answer the question. Provide details and share your research!
But avoid …
- Asking for help, clarification, or responding to other answers.
- Making statements based on opinion; back them up with references or personal experience.
To learn more, see our tips on writing great answers.
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f55670315%2fhow-should-i-replace-vectoruint8-tconst-iterator-in-an-api%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Is there a C++ alternative that's fairly generic?
Templates.– tkausl
1 hour ago
typedef vector<uint8_t>::const_iterator it_t;
orusing it_t= vector<uint8_t>::const_iterator;
will make it cleaner.– Mirko
1 hour ago
1
I like the callback approach, passing a consumer object with a callback for each kind of result produced. When the method return you give the guaranty that at most one callback has been called. But you could also have an async variant. The API could evolve by adding more callback to the consumer. std::variant is also good but may require the user to check which one is available (doesn't really change from two optionals).
– semako
1 hour ago