Can I send char as array argument?

[Uncle]

I am an untrained hobbyist. Everything about programming I have learned
from the internet. Thank you all for your gracious support.

This is what I have:

#define CONST_CHAR 0
void some_func( char* arg, int len )
{
// stuff
}

Most times there is a character array sent as "arg", but sometimes I only
need to send a single character.

Don't laugh, I know this doesn't work:
void main( void )
{
some_func( (char*)CONST_CH AR, 1 );
}

This does, and it is what I'm doing now:
void main( void )
{
char array[1];
array[0] = CONST_CHAR;
some_func( array, 1 );
}

My questions are:
Is there a way to construct the arg that looks more like the first
non-working example? If there is, would it make any difference in not
having to allocate an array, ( albeit one byte, ) to send a single
character?

[Ben Pfaff]

"Uncle" <[e-mail]> writes:

[for passing a pointer to a single character]

Don't laugh, I know this doesn't work:
void main( void )
{
some_func( (char*)CONST_CH AR, 1 );
}

This does, and it is what I'm doing now:
void main( void )
{
char array[1];
array[0] = CONST_CHAR;
some_func( array, 1 );
}
Alternatively, you don't need the array syntax:

char c = CONST_CHAR;
some_func(&c, 1);
My questions are:
Is there a way to construct the arg that looks more like the first
non-working example?

In C99, you can write
some_func((char[]){CONST_CHAR});
or
some_func(&(cha r){CONST_CHAR}) ;
But you probably don't have a C99 compiler.
--
"This is a wonderful answer.
It's off-topic, it's incorrect, and it doesn't answer the question."
--Richard Heathfield

[Bruce Percy]

On Fri, 05 Dec 2003 18:53:19 -0500, Uncle wrote:

I am an untrained hobbyist. Everything about programming I have learned
from the internet. Thank you all for your gracious support.

This is what I have:

#define CONST_CHAR 0
void some_func( char* arg, int len )
{
// stuff
}

Most times there is a character array sent as "arg", but sometimes I only
need to send a single character.

Don't laugh, I know this doesn't work:
void main( void )
{
some_func( (char*)CONST_CH AR, 1 );
}

This does, and it is what I'm doing now:
void main( void )
{
char array[1];
array[0] = CONST_CHAR;
some_func( array, 1 );
}

My questions are:
Is there a way to construct the arg that looks more like the first
non-working example? If there is, would it make any difference in not
having to allocate an array, ( albeit one byte, ) to send a single
character?

#include <stdio.h>

void some_func(const char* arg, int len )
{
int i;
for(i = 0; i < len; ++i)
printf("%c", arg[i]);
}

int main(void)
{
const char CONST_CHAR = '0';
some_func(&CONS T_CHAR, 1);
return 0;
}

[Uncle]

"Ben Pfaff" <bl*@cs.stanfor d.edu> wrote in message
news:87******** ****@pfaff.stan ford.edu...

"Uncle" <[e-mail]> writes:

[for passing a pointer to a single character]

Don't laugh, I know this doesn't work:
void main( void )
{
some_func( (char*)CONST_CH AR, 1 );
}

This does, and it is what I'm doing now:
void main( void )
{
char array[1];
array[0] = CONST_CHAR;
some_func( array, 1 );
}

Alternatively, you don't need the array syntax:

char c = CONST_CHAR;
some_func(&c, 1);

My questions are:
Is there a way to construct the arg that looks more like the first
non-working example?

In C99, you can write
some_func((char[]){CONST_CHAR});
or
some_func(&(cha r){CONST_CHAR}) ;
But you probably don't have a C99 compiler.
--
"This is a wonderful answer.
It's off-topic, it's incorrect, and it doesn't answer the question."
--Richard Heathfield

Thanks.

I guess I don't have C99. I'm using freebies ( lcc and gcc. )
When I used some_func( &(char)CONST_CH AR ) the compiler complained:
"left hand side can't be assigned to."
I'm sure it wouldn't understand the braces at all.

[Ben Pfaff]

"Uncle" <[e-mail]> writes:

"Ben Pfaff" <bl*@cs.stanfor d.edu> wrote in message
news:87******** ****@pfaff.stan ford.edu...

In C99, you can write
some_func((char[]){CONST_CHAR});
or
some_func(&(cha r){CONST_CHAR}) ;
But you probably don't have a C99 compiler.

I guess I don't have C99. I'm using freebies ( lcc and gcc. )
When I used some_func( &(char)CONST_CH AR ) the compiler complained:
"left hand side can't be assigned to."
I'm sure it wouldn't understand the braces at all.

The braces are essential. Without the braces, it's a cast; with
the braces, it's a compound literal.
--
"You call this a *C* question? What the hell are you smoking?" --Kaz

[Kevin Goodsell]

Uncle wrote:

I am an untrained hobbyist. Everything about programming I have learned
from the internet. Thank you all for your gracious support.
That's a very poor way to learn. Most of us work our asses off to learn
from real sources, and you are putting yourself way behind the game by
using the (mostly completely inadequate) sources available on the 'net.

This is what I have:

#define CONST_CHAR 0
void some_func( char* arg, int len )
{
// stuff
}

Most times there is a character array sent as "arg", but sometimes I only
need to send a single character.
char single_characte r = 's';
some_func(&sing le_character, 1);

Or create a separate function that takes a single char.

Don't laugh, I know this doesn't work:
void main( void )
main returns int. void is not and never has been an acceptable return
type for main.

int main(void)
{
some_func( (char*)CONST_CH AR, 1 );
This cast isn't even necessary, but the result (with or without the
cast) is to pass the function a null pointer.
}

This does, and it is what I'm doing now:
void main( void )
int main(void)
{
char array[1];
array[0] = CONST_CHAR;
some_func( array, 1 );
}

My questions are:
Is there a way to construct the arg that looks more like the first
non-working example? If there is, would it make any difference in not
having to allocate an array, ( albeit one byte, ) to send a single
character?

A single char (or rather, the address of a single char) is mostly
indistinguishab le from a 1 element char array.

Beware, though. Many functions taking a char* actually expect a pointer
to a (properly terminated) string. In which case, the best you can do
with a single char is pass the empty string:

char c = '\0';
some_func(&c, 1);

(Usually a function taking a string wouldn't also take its length, of
course.)

-Kevin
--
My email address is valid, but changes periodically.
To contact me please use the address from a recent posting.

[August Derleth]

"Uncle" <[e-mail]> wrote in
news:fL******** ******@bignews4 .bellsouth.net on Fri 05 Dec 2003 05:53:21p:

"Ben Pfaff" <bl*@cs.stanfor d.edu> wrote in message
news:87******** ****@pfaff.stan ford.edu...

"Uncle" <[e-mail]> writes:

[for passing a pointer to a single character]

> My questions are:
> Is there a way to construct the arg that looks more like the first
> non-working example?

In C99, you can write some_func((char[]){CONST_CHAR}); or
some_func(&(cha r){CONST_CHAR}) ; But you probably don't have a C99
compiler. --
"This is a wonderful answer.
It's off-topic, it's incorrect, and it doesn't answer the question."
--Richard Heathfield

Thanks.

I guess I don't have C99. I'm using freebies ( lcc and gcc. )

gcc implements a surprising amount of C99, but it isn't a conformant C99
compiler in any of its modes. C89 and C90 are more common these days, and
one could argue that they are the `true' standard in lieu of wide
acceptance of C99.

(gcc also implements some odd extensions to C, such as nested subroutines
(that is, subroutines declared inside subroutines, as per Pascal and Ada),
but such things are not on-topic here. I mention it simply because I
cannot understand why people writing a C compiler felt compelled to
implement nested subroutines.)

I don't know how conformant lcc is to anything, but I don't use it.

[Anupam]

"Uncle" <[e-mail]> wrote in message news:<xS******* *******@bignews 6.bellsouth.net >...

I am an untrained hobbyist. Everything about programming I have learned
from the internet. Thank you all for your gracious support.

This is what I have:

#define CONST_CHAR 0
void some_func( char* arg, int len )
{
// stuff
}

Most times there is a character array sent as "arg", but sometimes I only
need to send a single character.

Don't laugh, I know this doesn't work:
void main( void )
{
some_func( (char*)CONST_CH AR, 1 );
} Presumably, you are passing the address of this character to modify
its contents. However if it is a constant ...is it? It sure seems so
(from CONST_CHAR) ... then you may not modify a constant. The results
of such
a thing is undefined.
For instance :
char *a="abc";
a[0]='k';
This is undefined behaviour.

This does, and it is what I'm doing now:
void main( void )
{
char array[1]; /* Or char ch; */
array[0] = CONST_CHAR; /* Or ch=CONST_CHAR; */
some_func( array, 1 ); /* Or some_func(&ch,1 );
} Here you are storing it in a variable and passing its address. Quite
different from casting a 0 to a char*, I would say.
My questions are:
Is there a way to construct the arg that looks more like the first
non-working example? If there is, would it make any difference in not
having to allocate an array, ( albeit one byte, ) to send a single
character?

You just have to store your literal someplace and pass the address
I'm
afraid.
Regards,
Anupam

[Uncle]

"Anupam" <an************ **@persistent.c o.in> wrote in message
news:aa******** *************** **@posting.goog le.com...

This is what I have:

#define CONST_CHAR 0
void some_func( char* arg, int len )
{
// stuff
} Presumably, you are passing the address of this character to modify
its contents. However if it is a constant ...is it? It sure seems so
(from CONST_CHAR) ... then you may not modify a constant. The results
of such
a thing is undefined.
Actually some_func is basically just this:
void some_func( char* arg, int len )
{
mutex_release() ;
try_send( fd, arg, len, 0 );
mutex_aquire();
}
If the thread doesn't have the mutex it won't get here,
and try_send is just a socket send that closes fd and sets an error flag
on failure.
I put the mutex stuff in because I was afraid send might take a little time
to return.
"arg" is not modified.
For instance :
char *a="abc";
a[0]='k';
This is undefined behaviour.

I don't understand why this is undefined.
int main( void )
{
char *a="abc";
a[0]='k';
printf( a );
}
ouputs "kbc" on both of my systems. I would like to know where it might not
work, since I have quite a bit of this sort of thing in my code.

Just wondering, too; ( remember-- I'm untrained )
Is char*a above null terminated by the assignment? Is there a valid a[4] ==
'\0' ?

[A. Sinan Unur]

"Uncle" <[e-mail]> wrote in
news:kd******** *****@bignews3. bellsouth.net:

"Anupam" <an************ **@persistent.c o.in> wrote in message
news:aa******** *************** **@posting.goog le.com...

For instance :
char *a="abc";
a[0]='k';
This is undefined behaviour.

I don't understand why this is undefined.

http://www.eskimo.com/~scs/C-faq/q16.6.html
int main( void )
{
char *a="abc";
a[0]='k';
printf( a );
}
ouputs "kbc" on both of my systems. I would like to know where it
might not work, since I have quite a bit of this sort of thing in my
code.
also http://www.eskimo.com/~scs/C-faq/q1.32.html
Just wondering, too; ( remember-- I'm untrained )
Is char*a above null terminated by the assignment? Is there a valid
a[4] == '\0' ?

You are forgetting that C arrays are zero-based. Hence:

char *a = "abc";

means

a[0] == 'a' && a[1] == 'b' && a[2] == 'c'; && a[3] == '\0'

a[4] is out of bounds.

Also,

http://www.eskimo.com/~scs/C-faq/q4.10.html

seems relevant to your subject line.
--
A. Sinan Unur
as**@c-o-r-n-e-l-l.edu
Remove dashes for address
Spam bait: mailto:uc*@ftc. gov