How should I specify size?

[William Payne]

Hello, when using cin.getline() with a char array, how should I specify the
size (the second parameter of getline)?

const int buffer_size = 256;
char buffer[buffer_size];

std::cin.getline(buffer, std::streamsize(buffer_size));
or
std::cin.getline(buffer, buffer_size);
?

I know, I should use std::string and I usually do, but I still want to know
the proper way. I am writing a program that will be probably converted to C
so I ended up with char arrays instead of std::string, and the program uses
a third-party api which is based on C.

// William Payne

[Mike Wahler]

"William Payne" <mi******************@student.liu.se> wrote in message
news:bv**********@news.island.liu.se...

Hello, when using cin.getline() with a char array, how should I specify the size (the second parameter of getline)?

const int buffer_size = 256;
char buffer[buffer_size];

std::cin.getline(buffer, std::streamsize(buffer_size));
or
std::cin.getline(buffer, buffer_size);
?

I know, I should use std::string and I usually do, but I still want to know the proper way. I am writing a program that will be probably converted to C so I ended up with char arrays instead of std::string, and the program uses a third-party api which is based on C.

The C++ standard shows these prototypes:

basic_istream<charT,traits>& getline(char_type* s, streamsize n);
basic_istream<charT,traits>& getline(char_type* s, streamsize n,
char_type delim);

so I'd use 'streamsize' type.

But with C, you don't have that type, use 'size_t' to specify
object sizes or counts. And when calling library functions,
simply use whatever type the prototype specifies.
-Mike

[William Payne]

"Mike Wahler" <mk******@mkwahler.net> wrote in message
news:_0*****************@newsread1.news.pas.earthl ink.net...

"William Payne" <mi******************@student.liu.se> wrote in message
news:bv**********@news.island.liu.se...

Hello, when using cin.getline() with a char array, how should I specify the

size (the second parameter of getline)?

const int buffer_size = 256;
char buffer[buffer_size];

std::cin.getline(buffer, std::streamsize(buffer_size));
or
std::cin.getline(buffer, buffer_size);
?

I know, I should use std::string and I usually do, but I still want to

know

the proper way. I am writing a program that will be probably converted

to C

so I ended up with char arrays instead of std::string, and the program

uses

a third-party api which is based on C.

The C++ standard shows these prototypes:

basic_istream<charT,traits>& getline(char_type* s, streamsize n);
basic_istream<charT,traits>& getline(char_type* s, streamsize n,
char_type delim);

so I'd use 'streamsize' type.

But with C, you don't have that type, use 'size_t' to specify
object sizes or counts. And when calling library functions,
simply use whatever type the prototype specifies.
-Mike

Thanks alot for your reply, Mike. I will use std::streamsize.

/ William Payne

[David Rubin]

William Payne wrote:

Hello, when using cin.getline() with a char array, how should I specify the
size (the second parameter of getline)?

const int buffer_size = 256;
char buffer[buffer_size];

std::cin.getline(buffer, std::streamsize(buffer_size));
or
std::cin.getline(buffer, buffer_size);
?

std::cin.getline(buffer, sizeof buffer);

/david

--
Andre, a simple peasant, had only one thing on his mind as he crept
along the East wall: 'Andre, creep... Andre, creep... Andre, creep.'
-- unknown

[Jack Klein]

On Mon, 02 Feb 2004 20:02:02 GMT, "Mike Wahler"
<mk******@mkwahler.net> wrote in comp.lang.c++:

"William Payne" <mi******************@student.liu.se> wrote in message
news:bv**********@news.island.liu.se...

Hello, when using cin.getline() with a char array, how should I specify

the

size (the second parameter of getline)?

const int buffer_size = 256;
char buffer[buffer_size];

std::cin.getline(buffer, std::streamsize(buffer_size));
or
std::cin.getline(buffer, buffer_size);
?

I know, I should use std::string and I usually do, but I still want to

know

the proper way. I am writing a program that will be probably converted to

C

so I ended up with char arrays instead of std::string, and the program

uses

a third-party api which is based on C.

The C++ standard shows these prototypes:

basic_istream<charT,traits>& getline(char_type* s, streamsize n);
basic_istream<charT,traits>& getline(char_type* s, streamsize n,
char_type delim);

so I'd use 'streamsize' type.

But with C, you don't have that type, use 'size_t' to specify
object sizes or counts. And when calling library functions,
simply use whatever type the prototype specifies.
-Mike

I disagree here, Mike. Since C++ requires a proper prototype in
scope, the conversion is automatic. The functional-like cast just
adds unnecessary clutter in this case.

My rule is never provide an explicit cast for an implicit automatic
loss-less conversion unless the circumstances are complex enough that
someone reading the code might be mislead.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://www.eskimo.com/~scs/C-faq/top.html
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html

[Mike Wahler]

"Jack Klein" <ja*******@spamcop.net> wrote in message
news:cu********************************@4ax.com...

On Mon, 02 Feb 2004 20:02:02 GMT, "Mike Wahler"
<mk******@mkwahler.net> wrote in comp.lang.c++:

"William Payne" <mi******************@student.liu.se> wrote in message
news:bv**********@news.island.liu.se...

Hello, when using cin.getline() with a char array, how should I

specify the

size (the second parameter of getline)?

const int buffer_size = 256;
char buffer[buffer_size];

std::cin.getline(buffer, std::streamsize(buffer_size));
or
std::cin.getline(buffer, buffer_size);
?

I know, I should use std::string and I usually do, but I still want to know

the proper way. I am writing a program that will be probably converted

to C

so I ended up with char arrays instead of std::string, and the program

uses

a third-party api which is based on C.

The C++ standard shows these prototypes:

basic_istream<charT,traits>& getline(char_type* s, streamsize n);
basic_istream<charT,traits>& getline(char_type* s, streamsize n,
char_type delim);

so I'd use 'streamsize' type.

But with C, you don't have that type, use 'size_t' to specify
object sizes or counts. And when calling library functions,
simply use whatever type the prototype specifies.
-Mike

I disagree here, Mike. Since C++ requires a proper prototype in
scope, the conversion is automatic. The functional-like cast just
adds unnecessary clutter in this case.

But do we have any guarantee that 'streamsize' is at least as large
as e.g. 'int'?

My rule is never provide an explicit cast for an implicit automatic
loss-less conversion unless the circumstances are complex enough that
someone reading the code might be mislead.

I Agree.

-Mike

[Martijn Lievaart]

On Tue, 03 Feb 2004 18:13:14 +0000, Mike Wahler wrote:

But do we have any guarantee that 'streamsize' is at least as large
as e.g. 'int'?

Actually not, 27.4.1 clause 2:

"The type streamsize is a synonym for one of the signed basic integral
types. It is used to represent the number of characters transferred in an
I/O operation, or the size of I/O buffers.266)"

So the standard allows signed char. In practice it should be at least the
signed couterpart to size_t, but I think this is a defect.

M4