关于 extern 的错误，帮忙改一下

[今天tjj]

//*****************************************
// new.h

#ifndef NEW_H_
#define NEW_H_

void * new(const void * type, ...);
void delete(void * item);

#endif

//******************************************
// object.h

#ifndef OBJECT_H_
#define OBJECT_H_

extern const void * object;

int differ(const void * a, const void * b);

#endif

//******************************************
// set.h

#ifndef SET_H_
#define SET_H_

extern const void * set;

void * add(void * set, const void * element);
void * find(const void * set, const void * element);
void * drop(void * set, const void * element);
int contains(const void * set, const void *element);

#endif
//*******************************************
// new.c

#include "new.h"
#include <assert.h>

#if !defined MANY || MANY < 1
#define MANY 10
#endif

static int heap[MANY];

void * new(const void * type, ...)
{
int *p;

for (p = heap + 1; p < heap + MANY; p++)
if (!*p)
break;
assert(p < heap + MANY);
*p = MANY;

return (void *)p;
}

void delete(void * item)
{
int * _item = item;

if (_item)
{
assert(_item > heap && _item < heap + MANY);
*_item = 0;
}

return;
}

//************************************************************
// object.c

#include "object.h"

int differ(const void * a, const void * b)
{
return a != b;
}
//***********************************************************
// set.c

#include "set.h"
#include "new.h"
#include <assert.h>

extern static int heap;

void * add(void * set, const void * element)
{
int * _set = set;
const int * _element = element;

assert(_set > heap && _set < heap + MANY);
assert(*_set == MANY);
assert(_element > heap && _element < heap + MANY);

if (*_element == MANY)
*(int *)_element = set - heap;
else
assert(*_element == set - heap);

return (void *)_element;
}

void * find(const void * set, const void * element)
{
const int * _set = set;
const int * _element = element;

assert(_set > heap && _set < heap + MANY);
assert(*_set == MANY);
assert(_element > heap && _element < heap + MANY);
assert(*_element);

return *_element == set - heap ? (void *)_element : NULL;
}

void * drop(void * set, const void * element)
{
int * _element = find(set, element);
if (_element)
*_element = MANY;

return (void *)_element;
}

int contains(const void * set, const void * element)
{
return find(set, element) != NULL;
}

//***************************************************
// main.c

#include "new.h"
#include "object.h"
#include "set.h"
#include <stdio.h>

int main(void)
{
const void * set = NULL;
const void * object = NULL;

void * s = new(set);
void * a = add(s, new(object));
void * b = add(s, new(object));
void * c = new(object);

if (contains(s, a) && contains(s, b))
puts("OK");
if (contains(s, c))
puts("contain?");
if (differ(a, add(s, a)))
puts("differ?");
delete(drop(s, b));
delete(drop(s, c));

return 0;
}

[lingyin55]

extern表示该函数可以被其它文件调用，而static则声明在本文件中使用，两者不能混合用。

[pengzhixi]

extern static int heap;
static变量是不可以用extern来修饰的,它不具备有外连性.

[benpao8]

extern 和 static 要互斥使用。
能够被extern的，都不能使static。
凡是static过的，就不能再extern

[zhanghuayi_xiyou]

extern修饰全局变量。而static修饰文件域变量。

不能一起使用

[zjf30366]

extern 和 static 的作用域不同。

[老邓]

原来楼主也在研究OOC的代码啊。
好啊。
我也在看，并且正在研究构造函数与析构函数：有空到我的帖子看看：http://topic.csdn.net/u/20090418/17/40711856-e144-4281-b1fc-7d44d545e59f.html

你set.c的代码有问题，看我这个：

#include <assert.h>
#include <stdio.h>

#include "new.h"
#include "Set.h"
#include "Object.h"

const void * Set;
const void * Object;

#if ! defined MANY || MANY < 1
#define MANY 10
#endif

static int heap [MANY];

void * new(const void * type, ...)
{
    int * p;       /* & heap[1..] */

    for (p = heap + 1; p < heap + MANY; ++ p)
        if (! * p)
            break;
    assert(p < heap + MANY);
    * p = MANY;
    return p;
}

void delete(void * _item)
{
    int * item = _item;

    if (item)
    {
        assert(item > heap && item < heap + MANY);
        * item = 0;
    }
}

void * add(void * _set, const void * _element)
{
    int * set = _set;
    const int * element = _element;

    assert(set > heap && set < heap + MANY);
    assert(* set == MANY);
    assert(element > heap && element < heap + MANY);

    if (* element == MANY)
        * (int *) element = set - heap;
    else
        assert(* element == set - heap);

    return (void *) element;
}

void * find(const void * _set, const void * _element)
{
    const int * set = _set;
    const int * element = _element;

    assert(set > heap && set < heap + MANY);
    assert(* set == MANY);
    assert(element > heap && element < heap + MANY);
    assert(* element);

    return * element == set - heap ? (void *) element : 0;
}

int contains(const void * _set, const void * _element)
{
    return find(_set, _element) != 0;
}

void * drop(void * _set, const void * _element)
{
    int * element = find(_set, _element);

    if (element)
        * element = MANY;
    return element;
}

int differ(const void * a, const void * b)
{
    return a != b;
}

[changhe325]

顶下

[xuguod20042576]

static声明后,只能在本文件中使用,extern声明可以在其他文件中使用,extern static int heap像这样的声明应该是不正确的,要么是extern,要么是static

[jackyjkchen]

extern static……我没见过这么用的……

[coverallwangp]

extern代表此变量是在别的文件中定义，而static变量只能在本文件中使用，不能被别的文件使用。
所以这两个不能用在一起

[猫已经找不回了]

extern static int heap;

没见过这样用的.你看下说明
http://blog.chinaunix.net/u1/34605/showart_350073.html