:523: error: invalid lvalue in assignment

hello,
how can i solve this problem ........

error: invalid lvalue in assignment

Code:

if(c==0)
		{
			(char **)sTmp= &sd->source;
			nl=sd->sbound;
		}

this is my structure

Code:

struct _sd
{
	char source[MAXHOSTIP][MAXHOSTLENGHT];
	char   dest[MAXHOSTIP][MAXHOSTLENGHT];
	int sbound;
	int dbound;
};

struct _tcp_udp
{
	struct _sd sd;
	int ports[MAXPORTS];
};

struct _tcprst
{
	struct _sd sd;
	int seq;
	int source_port;
	int dest_port;
};

struct _icmp_igmp
{
	struct _sd sd;
};

struct listofip
{
	struct _tcp_udp		tcp;
	struct _tcp_udp		udp;
	struct _icmp_igmp	icmp;
	struct _icmp_igmp	igmp;
	struct _tcprst		trst;
}ltp;

but when i am using like this

Code:

if(c==0)
		{
			sTmp= &sd->source;
			nl=sd->sbound;
		}

Code:

int ResolveHostIP(char* argv, struct _sd *sd)
{
int i,c=0,nC,nl;
struct hostent*hp;
 struct _sTmp
 {
	char szTmp[MAXHOSTIP][MAXHOSTLENGHT];
 }*sTmp;

Getting this warning
warning: assignment from incompatible pointer type
what will be the right syntax.

So if that last bit of code is to be believed sTmp points to a struct _sTmp? If so, the obvious (and, fortunately, correct) way to do this would be to memcpy sd->source to sTmp->szTmp. They're both two-dimensional arrays of chars, which means that the memory is already there (arrays allocate their own memory) and guaranteed to be both (a) in one continuous piece and (b) of the same size (assuming of course that sTmp and sd both point to legitimate structures and not to Hoboken).

Btw, as for your errors...
It's illegal to do a cast on the left side of the type you're assigning to. You must cast the source (what you're assigning) to the correct destination type (what you're assigning to). Note that in this case, as tabstop so kindly points out, it may not be the right thing to do.

Example:

Code:

int myint = 0;
float myfloat = 0.0f;
int* pMyInt = NULL;
pMyInt = (int*)&myfloat;
/* Not (float*)pMyInt = &myfloat; */

By an explicit cast, it works. But this example is not recommended practice.

And the warning means that you're trying to assign a pointer of type Y* to type X*, or in other words, you're trying to assign a pointer pointing to a different type than the pointer you're trying to assign to.

Example:

Code:

int myint = 0;
float myfloat = 0.0f;
int* pMyInt = NULL;
pMyInt = &myfloat;

This, for some reason, compiles in C, but is bad, because &myfloat is float* and pMyInt is int*, thus different types, hence the warning.

You CAN use casts on the left-side, but not direct type conversions, e.g:

Code:

int *pInt;
float f = 3.13;

*(float **)&pInt = &f;

--
Mats

The standard is just full of loopholes and exceptions everywhere, isn't it?

Originally Posted by Elysia

The standard is just full of loopholes and exceptions everywhere, isn't it?

Well, it's really about the rule of what a lvalue is: It is something that can be assigned to, and (float)blah is not a valid lvalue, but *(float *) is, for example [then, to make valid code, executable code, you have to make sure that casted value points to a valid memory location of the correct size for a float - but this construct is OFTEN used for addressing directly to hardware memory locations - rarely with float, but with specificly sized integers].

--
Mats

Unfortunately, the whole l-value vs r-value and rules and regulations are becoming so extremely complicated with all exceptions and rules it's impossible to tell what's possible and not.
If a cast can be done before the l-value and it produces a correct l-value, then it should be possible. This also means a cast to a non-pointer type. Technically, it might create a new, temporary variable as a result of the operation, but then again, it might not - it could be implemented either way.

Originally Posted by Elysia

Unfortunately, the whole l-value vs r-value and rules and regulations are becoming so extremely complicated with all exceptions and rules it's impossible to tell what's possible and not.
If a cast can be done before the l-value and it produces a correct l-value, then it should be possible. This also means a cast to a non-pointer type. Technically, it might create a new, temporary variable as a result of the operation, but then again, it might not - it could be implemented either way.

The rule is actually simple: an lvalue is anything that can be assigned to. A type-case of something can not be assigned to, a dereference of something that is a typecast of a pointer can.

--
Mats

That makes no sense. A cast changes the type of something to another, so changing from int to float should still be valid, without the use of pointers and dereferencing them.

Originally Posted by Elysia

That makes no sense. A cast changes the type of something to another, so changing from int to float should still be valid, without the use of pointers and dereferencing them.

Yes, but remember: you're assigning to things. If you have char b and you try to assign something to (float) b, where are you going to put it? There's no memory address there. But assigning to a dereferenced pointer always has a memory address available (to wit, the pointer).

That's what I figured and which is also what I asked why the implementation cannot simply change the type of the variable assigned to first and then assign. Perhaps it wouldn't work if the type is too large, though.
But in any case, as with any temporaries, the compiler could create a temporary to assign to, then assign to the destination.
But I'm guessing this is not allowed in the standard.