redeclaration of 'p' with no linkage

[Ravi]

#include <stdio.h>
int main(void)
{
int i, j, *p;
i = 25;
j = 100;
int *p = &i;
}

When I compiled the above code with gcc I goth the message :
"redeclaration of 'p' with no linkage" .
What does this mean. Can You please explain?

[pete]

Ravi wrote:

>
#include <stdio.h>
int main(void)
{
int i, j, *p;
i = 25;
j = 100;
int *p = &i;
}

When I compiled the above code with gcc I goth the message :
"redeclaration of 'p' with no linkage" .
What does this mean.

It means that p has no linkage and that you declared p twice.

Can You please explain?

It's easier just to fix the code:

#include <stdio.h>

int main(void)
{
int i, j, *p;

i = 25;
j = 100;
p = &i;
}

--
pete

[Mark McIntyre]

On Sun, 19 Aug 2007 14:43:13 -0000, in comp.lang.c , Ravi
<ra*********@gmail.comwrote:

>#include <stdio.h>
int main(void)
{
int i, j, *p;

here you declared p as a pointr to an int.

i = 25;
j = 100;
int *p = &i;

here, you tried to declare it again.

Both declarations don't specify the linkage - that is, they don't say
that the object is extern (external linkage) or static (internal
linkage) .

Such objects have 'no linkage' and you can't have two of them in the
same scope. See 6.2.2 of the Standard.

--
Mark McIntyre

"Debugging is twice as hard as writing the code in the first place.
Therefore, if you write the code as cleverly as possible, you are,
by definition, not smart enough to debug it."
--Brian Kernighan

[CBFalconer]

Ravi wrote:

>
#include <stdio.h>
int main(void) {
int i, j, *p;
i = 25;
j = 100;
int *p = &i;
}

When I compiled the above code with gcc I goth the message :
"redeclaration of 'p' with no linkage" .
What does this mean. Can You please explain?

You already declared it in the first line.

--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net>
--
Posted via a free Usenet account from http://www.teranews.com

[Kenneth Brody]

Mark McIntyre wrote:

>
On Sun, 19 Aug 2007 14:43:13 -0000, in comp.lang.c , Ravi
<ra*********@gmail.comwrote:

#include <stdio.h>
int main(void)
{
int i, j, *p;

here you declared p as a pointr to an int.

i = 25;
j = 100;
int *p = &i;

here, you tried to declare it again.

Both declarations don't specify the linkage - that is, they don't say
that the object is extern (external linkage) or static (internal
linkage) .

Such objects have 'no linkage' and you can't have two of them in the
same scope. See 6.2.2 of the Standard.

Does that mean that this should be valid?

void foo(void)
{
static int *p;
int i;
extern int *p = &i;
}

My compiler doesn't allow it. (Ditto with other combinations of
static/extern/none.) They all give "'p' : redefinition".

(Not that I would ever knowingly use such a construct.)

--
+-------------------------+--------------------+-----------------------+
| Kenneth J. Brody | www.hvcomputer.com | #include |
| kenbrody/at\spamcop.net | www.fptech.com | <std_disclaimer.h|
+-------------------------+--------------------+-----------------------+
Don't e-mail me at: <mailto:Th*************@gmail.com>

[Harald van =?UTF-8?B?RMSzaw==?=]

Kenneth Brody wrote:

Mark McIntyre wrote:

>>
On Sun, 19 Aug 2007 14:43:13 -0000, in comp.lang.c , Ravi
<ra*********@gmail.comwrote:

>#include <stdio.h>
int main(void)
{
int i, j, *p;

here you declared p as a pointr to an int.

i = 25;
j = 100;
int *p = &i;

here, you tried to declare it again.

Both declarations don't specify the linkage - that is, they don't say
that the object is extern (external linkage) or static (internal
linkage) .

Such objects have 'no linkage' and you can't have two of them in the
same scope. See 6.2.2 of the Standard.

Does that mean that this should be valid?

void foo(void)
{
static int *p;
int i;
extern int *p = &i;
}

My compiler doesn't allow it. (Ditto with other combinations of
static/extern/none.) They all give "'p' : redefinition".

In this case, static does not imply internal linkage. A block-scope object
defined with the keyword 'static' has no linkage. A file-scope object
defined with the keyword 'static' has internal linkage.

Additionally, objects with static storage duration must have constant
initialisers, which &i is not, and block-scope declarations of objects with
linkage may not even have any initialiser at all.

But your compiler should not object to

void foo(void)
{
extern int *p;
extern int *p;
}

nor to

static int *p;
void foo(void)
{
extern int *p;
extern int *p;
}

[Mark McIntyre]

On Mon, 20 Aug 2007 14:31:47 -0400, in comp.lang.c , Kenneth Brody
<ke******@spamcop.netwrote:

>Mark McIntyre wrote:

>>
Such objects have 'no linkage' and you can't have two of them in the
same scope. See 6.2.2 of the Standard.

Does that mean that this should be valid?

void foo(void)
{
static int *p;
int i;
extern int *p = &i;
}

My compiler doesn't allow it.

Interesting - I think that this ought to be allowed by 6.2.2p4,
though I'm happy to be corrected. Is this a C89 vs C99 thing?

"For an identifier declared with the storage-class specifier extern in
a scope in which a prior declaration of that identifier is visible, if
the prior declaration specifies internal or external linkage, the
linkage of the identifier at the later declaration is the same as the
linkage specified at the prior declaration. If no prior declaration is
visible, or if the prior declaration specifies no linkage, then the
identifier has external linkage."
--
Mark McIntyre

"Debugging is twice as hard as writing the code in the first place.
Therefore, if you write the code as cleverly as possible, you are,
by definition, not smart enough to debug it."
--Brian Kernighan