Видимость констант из глобальной области внутри класса

@outoftime · Регистрация: 25.07.2009

C++

#include <iostream>
 
//stack struct
struct node;
struct node
{
    int* val;
    node* prev;
};
typedef struct node node
 
//const initialize
const int heap_size = 60*1000,
          block_size = 19;
 
class Memory
{
public:
    Memory();
    ~Memory();
    int* find();
    void free();
private:
    int* bit_set;
    int* heap;
};
 
class stack
{
public:
    stack();
    ~stack();
    void push(int &n);
    int pop();
private:
    node* head;
    int top;
};
 
int main()
{
    Memory::Memory();
    return 0;
}
 
Memory::Memory()
{
    bit_set = (int *) calloc (heap_size, sizeof(int));
    heap = (int *) malloc(heap_size * block_size * sizeof(int));
}

У проблема получается в том, что heap_size и block_size - невидимые в класе Memory. Можно ли это кок-то исправить?

valeriikozlov · 11.01.2010, 07:42

Почему Вы решили что они не видимые в классе Memory? В данном случае они видимые. В случае сокрытия их локальными переменными все равно их можно достать используя "::"

@outoftime · 11.01.2010, 08:05 **[ТС]**

valeriikozlov, я вас немного не понял, т.е. пространство имен для гловальной области не существует и доступ к переменнтым осуществляется просто :: ?
Кстати у меня ошибка была здесь:

C++

1	typedef struct node node

valeriikozlov · 11.01.2010, 08:18

Сообщение от outoftime

Кстати у меня ошибка была здесь: Код C++
1
2
typedef struct node node

я сейчас про другие ошибки не говорю, но если речь пошла и за это, то еще нужно для деструктора Memory сделать реализацию, в которой нужно освободить память.
А в int main() вот этой строкой:

Memory::Memory();

что Вы хотели добиться?
Работать нужно в данном случае с создаваемыми экземплярами класса Memory. Например протестируйте так:

C

int main()
{
    Memory test;
    test.bit_set[2]=45;
    printf("%d", test.bit_set[2]);
    return 0;
}

только закоментируйте на время теста строку

private:

в классе Memory.

@outoftime · 11.01.2010, 09:23 **[ТС]**

C++

#include <iostream>
 
#define FOR(i,a,b) for (int i(a), _n(b); i < _n; ++i)
 
//stack struct------------------------------------------------------------------
 
struct node;
struct node
{
public:
    int* val;
    node* prev;
};
typedef struct node node;
 
//const initialize--------------------------------------------------------------
 
const int heap_size = 60*1000,
          block_size = 19;
          
//memory class------------------------------------------------------------------
 
class Memory
{
public:
    Memory();
    ~Memory();
    int* find();
    void free(int *);
private:
    int* bit_set,
       * heap;
};
 
//stack class-------------------------------------------------------------------
 
class stack
{
public:
    stack();
    ~stack();
    void push(int &);
    int pop();
private:
    node* head;
    int top;
};
 
//main--------------------------------------------------------------------------
 
int main()
{
    int n, d;
    char* s = new char[5];
    scanf("%d", &n);
    stack* a = new stack[1000];
    while(n--)
    {
        scanf("%s%d", s, &d);
        if (s[1] == 'U')
        {
            int dd;
            scanf("%d", &dd);
            a[d-1].push(dd);
        }
        else printf("%d", a[d-1].pop());
    }
    return 0;
}
 
//class Memory------------------------------------------------------------------
 
Memory::Memory()
{
    bit_set = (int *) calloc (heap_size, sizeof(int));
    heap = (int *) malloc(heap_size * block_size * sizeof(int));
}
 
Memory::~Memory()
{
    bit_set = (int *) realloc (bit_set, 0);
    heap = (int *) realloc (heap, 0);
}
 
int* Memory::find()
{
    FOR(i,0,heap_size)
        if (!bit_set[i])
        {
            bit_set[i] = 1;
            return (heap + i*block_size);
        }
    return 0;
}
 
void Memory::free(int *n)
{
    bit_set[ (n - heap)/block_size ] = 0;
}
 
//class stack-------------------------------------------------------------------
 
Memory my_mem;
 
stack::stack()
{
    top = 0;
    head = new node;
    head->prev = 0;
    head->val = my_mem.find();
}
 
stack::~stack()
{
    delete head;
}
 
void stack::push(int &n)
{
    if (top == block_size)
    {
        top = 0;
        node* tmp = new node;
        tmp->prev = head;
        tmp->val = my_mem.find();
        head = tmp;
    }
    else head->val[top++] = n;
}
 
int stack::pop()
{
    if (top == 0)
    {
        node* tmp = head;
        my_mem.free(tmp->val);
        head = head->prev;
        delete tmp;
        top = block_size-1;
        return head->val[top--];
    }
    else return head->val[top--];
}

А так? Она теперь выдает предпоследний элемент вместо последнего (вернее тот, который перед последним, что в даном случае разные вещи)
тема расположена по адресу: Быстрый стек, с малым обьемом памяти

valeriikozlov 4725 / 2546 / 757 Регистрация: 18.08.2009 Сообщений: 4,568
	11.01.2010, 07:42	2
	Почему Вы решили что они не видимые в классе Memory? В данном случае они видимые. В случае сокрытия их локальными переменными все равно их можно достать используя "::" 1

Опции темы