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

[Raja]

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

[John Harrison]

"Raja" <sh*******@yahoo.com> wrote in message
news:b2*************************@posting.google.co m...

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

Buffer size of what?

john

[Mike Wahler]

"Raja" <sh*******@yahoo.com> wrote in message
news:b2*************************@posting.google.co m...

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

[Julie]

Raja wrote:

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.

[Pete C.]

Julie wrote:

Raja wrote:

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.

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

- Pete

[Thomas Matthews]

Raja wrote:

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

You could use std::vector which can resize itself.
See also realloc().
--
Thomas Matthews

C++ newsgroup welcome message:
http://www.slack.net/~shiva/welcome.txt
C++ Faq: http://www.parashift.com/c++-faq-lite
C Faq: http://www.eskimo.com/~scs/c-faq/top.html
alt.comp.lang.learn.c-c++ faq:
http://www.raos.demon.uk/acllc-c++/faq.html
Other sites:
http://www.josuttis.com -- C++ STL Library book

[AngleWyrm]

"Julie" <ju***@nospam.com> wrote in message
news:40**************@nospam.com...

Raja wrote:

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.

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");
}

[Mats Weber]

"AngleWyrm" <no***************@hotmail.com> wrote in message news:<DPjAc.64455$0y.24244@attbi_s03>...

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 ?

[John Harrison]

"Mats Weber" <ma***@bluewin.ch> wrote in message
news:9c**************************@posting.google.c om...

"AngleWyrm" <no***************@hotmail.com> wrote in message news:<DPjAc.64455$0y.24244@attbi_s03>...

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

[John Harrison]

>

dummy is a reference to an array T of size N.

an array of T of size N

john

[David Rubin]

"John Harrison" <jo*************@hotmail.com> wrote in message

[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

[Alf P. Steinbach]

* David Rubin:

"John Harrison" <jo*************@hotmail.com> wrote in message

[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.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[John Harrison]

"David Rubin" <da********@warpmail.net> wrote in message
news:82*************************@posting.google.co m...

"John Harrison" <jo*************@hotmail.com> wrote in message

[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