By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
446,212 Members | 1,096 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 446,212 IT Pros & Developers. It's quick & easy.

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

P: n/a
How to know the buffer size and increase buffer size in c++.
Jul 22 '05 #1
Share this Question
Share on Google+
12 Replies


P: n/a

"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
Jul 22 '05 #2

P: n/a

"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
Jul 22 '05 #3

P: n/a
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.
Jul 22 '05 #4

P: n/a
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
Jul 22 '05 #5

P: n/a
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

Jul 22 '05 #6

P: n/a
"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");
}
Jul 22 '05 #7

P: n/a
"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 ?
Jul 22 '05 #8

P: n/a

"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
Jul 22 '05 #9

P: n/a
>
dummy is a reference to an array T of size N.


an array of T of size N

john
Jul 22 '05 #10

P: n/a
"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
Jul 22 '05 #11

P: n/a
* 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?
Jul 22 '05 #12

P: n/a

"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
Jul 22 '05 #13

This discussion thread is closed

Replies have been disabled for this discussion.