How to know the buffer size and increase buffer size in c++

M

Mike Wahler

Raja said:
How to know the buffer size

Decide what size you want, and remember that.
and increase buffer size in c++.

Add the desired amount to the above, and
change it to the new size.

Perhaps if you'd be more specific, we could
give a more specific answer.


-Mike
 
J

Julie

Raja said:
How to know the buffer size and increase buffer size in c++.

There is no intrinsic support in C++ to be able to determine the size of an
arbitrary allocated memory block (buffer?). You must keep track of the memory
block yourself.

To increase the size (when necessary), you simply need to allocate a new piece
of memory that is of suitable size, copy over the contents of the previous to
the new, update references to the previous to point to the new, and then
release the previous.
 
P

Pete C.

Julie said:
There is no intrinsic support in C++ to be able to determine the size
of an arbitrary allocated memory block (buffer?). You must keep
track of the memory block yourself.

To increase the size (when necessary), you simply need to allocate a
new piece of memory that is of suitable size, copy over the contents
of the previous to the new, update references to the previous to
point to the new, and then release the previous.

Of course there's also std::vector<> ...

- Pete
 
T

Thomas Matthews

A

AngleWyrm

Julie said:
There is no intrinsic support in C++ to be able to determine the size of an
arbitrary allocated memory block (buffer?). You must keep track of the memory
block yourself.

In a similar vein about determining allocated memory, I recently ran across
this little gem:

//
// A handy two-line array_size() template function
//
#include <cstdlib>
#include <iostream>
using namespace std;


// Uses template type induction to
// discover the size of an array
// so that you don't have to use sizeof(array)/sizeof(element)
template<typename T, int size>
int array_size(T (&)[size]) { return size; };


int main(){

int my_array[] = { 1, 2, 3, 4, 5 };// implicit size

cout << "array size is : " << array_size(my_array) << endl;

system("pause");
}
 
M

Mats Weber

AngleWyrm said:
In a similar vein about determining allocated memory, I recently ran across
this little gem:

//
// A handy two-line array_size() template function
//
#include <cstdlib>
#include <iostream>
using namespace std;


// Uses template type induction to
// discover the size of an array
// so that you don't have to use sizeof(array)/sizeof(element)
template<typename T, int size>
int array_size(T (&)[size]) { return size; };


int main(){

int my_array[] = { 1, 2, 3, 4, 5 };// implicit size

cout << "array size is : " << array_size(my_array) << endl;

system("pause");
}

That's great, and it's nice to know that there is something better
than sizeof. But I do not understand why it works. I looked up the
"(&)" syntax in Stroustrup's book but couldn't find it. Could someone
explain ?
 
J

John Harrison

Mats Weber said:
"AngleWyrm" <[email protected]> wrote in message
In a similar vein about determining allocated memory, I recently ran across
this little gem:

//
// A handy two-line array_size() template function
//
#include <cstdlib>
#include <iostream>
using namespace std;


// Uses template type induction to
// discover the size of an array
// so that you don't have to use sizeof(array)/sizeof(element)
template<typename T, int size>
int array_size(T (&)[size]) { return size; };


int main(){

int my_array[] = { 1, 2, 3, 4, 5 };// implicit size

cout << "array size is : " << array_size(my_array) << endl;

system("pause");
}

That's great, and it's nice to know that there is something better
than sizeof. But I do not understand why it works. I looked up the
"(&)" syntax in Stroustrup's book but couldn't find it. Could someone
explain ?

Perhaps easier to understand like this

template<typename T, size_t N>
size_t array_size(T (&dummy)[N]) { return N; }

dummy is a reference to an array T of size N. Because the parameter is
unused C++ allows you to omit it as AngleWyrm did.

john
 
D

David Rubin

[snip]
template<typename T, size_t N>
size_t array_size(T (&dummy)[N]) { return N; }

dummy is a reference to an array T of size N. Because the parameter is
unused C++ allows you to omit it as AngleWyrm did.

Of course, this generates a function for every different type T and
size N. It's more efficient to use

#define array_size(X) (sizeof X / sizeof *X)

which has the same semantics. You only lose some type-safety, but this
typically not a problem.

/david
 
A

Alf P. Steinbach

* David Rubin:
[snip]
template<typename T, size_t N>
size_t array_size(T (&dummy)[N]) { return N; }

dummy is a reference to an array T of size N. Because the parameter is
unused C++ allows you to omit it as AngleWyrm did.

Of course, this generates a function for every different type T and
size N.

No; the compiler is free to inline the result and will typically do so.

It's more efficient to use

#define array_size(X) (sizeof X / sizeof *X)

which has the same semantics.

No; the macro incorrectly accepts a pointer whereas the function
correctly does not, the macro works on an array of local element type
whereas the function does not, and the macro can be evaluated at compile
time whereas a bit more template magic is needed to achieve that.

You only lose some type-safety, but this typically not a problem.

No; those who think it's not a problem constitute a proper subset of
those who by using such things create problems for others or themselves.
 
J

John Harrison

David Rubin said:
[snip]
template<typename T, size_t N>
size_t array_size(T (&dummy)[N]) { return N; }

dummy is a reference to an array T of size N. Because the parameter is
unused C++ allows you to omit it as AngleWyrm did.

Of course, this generates a function for every different type T and
size N. It's more efficient to use

#define array_size(X) (sizeof X / sizeof *X)

which has the same semantics. You only lose some type-safety, but this
typically not a problem.

/david

Not necessarily, if you make the template version an inline function.

Your version suffers from the big problem that is will compile for pointers.
Its quite common for an array to change to a pointer, for instance when some
code is refactored into a different function but the array stays in the
original function and is passed to the new function as a pointer. In that
case your version will compile but give meaningless results. The template
version will give a compile error.

john
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

No members online now.

Forum statistics

Threads
473,733
Messages
2,569,440
Members
44,831
Latest member
HealthSmartketoReviews

Latest Threads

Top