STACK&POINTERS C/C++

#include<iostream>
#include<stddef.h>
using namespace std;

typedef struct u_stack_t {
    void * () store;
    void  () current;
    size_t capacity;
} u_stack_t;

u_stack_t  () u_create_stack();
u_stack_t  () u_create_stack_with_capacity(size_t capacity);
void  u_delete_stack(u_stack_t*);
void  () u_push_stack(u_stack_t*, void*, size_t);
void  () u_pop_stack(u_stack_t*, size_t);

u_stack_t  () u_create_stack_with_capacity(size_t capacity) {
    u_stack_t ()  stack = (u_stack_t*)malloc(sizeof(stack));
    if (stack) {
        stack->capacity = capacity + (sizeof(max_align_t) - capacity % sizeof(max_align_t));
        stack->store = malloc(capacity);
        if (stack->store) {
            stack->current = stack->store;
            return stack;
        }
        free(stack);
    }
    return NULL;
}

u_stack_t *create_stack() {
    u_stack_t* stack = (u_stack_t*)malloc(sizeof(stack));
    if(stack) {
    stack->capacity = sizeof(max_align_t);
    stack->store = malloc(stack->capacity);
    if (stack->store) {
        stack->current = stack->store;
        return stack;
    }
    free(stack);
    }
    return NULL;
}

void *u_push_stack(u_stack_t *stack, void *store, size_t capacity) {
    u_stack_t *newItem = (u_stack_t *)malloc(sizeof *newItem);
    if (newItem) {
    newItem -> store = store;
    newItem -> current = stack -> current;
    stack -> current = newItem;
    stack -> capacity += 1;
    }
}

bool stackIsEmpty(u_stack_t *stack)
{
    return stack -> current == NULL ? true : false;
}

/*void *u_pop_stack(u_stack_t *stack, size_t capacity)
{
	u_stack_t *oldTop;
	max_align_t item;

	if( stack -> current == NULL) {
        stack -> capacity = 0;
        stack -> current = NULL;
        stack -> store = NULL;
	}

	oldTop -> current = stack -> current;
//	item = oldTop->store;
	stack->current = oldTop->store;
	free(oldTop);
	oldTop = NULL;
	stack -> capacity -= 1;
}

/*void *u_push_stack(u_stack_t *stack, void*store, size_t capacity) {
    void *temp = new u_stack_t;
    cin >> temp->store;
    temp->current = *stack;
    *stack = temp;
}*/

void* stackTop(u_stack_t *stack)
{
	return (*(stack)).current;
}

int main() {

    u_stack_t* stack;
    u_stack_t* stacking;
    int *tab2;
    void *tab3;
    int tab[5];
    tab2 = &tab[0];
    //tab3 = tab2;
    //tab3 = &tab[0];
    tab[1] = 1;
    tab[2] = 2;
    tab[3] = 3;
    tab[4] = 4;
    tab[0] = 5;
  //  cout << *(tab + 1)  << endl;
    (*(stack)).current = (tab2 + 4);
    (*(stack)).store = tab2;
    (*(stack)).capacity = 5;
    cout << " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx  " << endl;
    u_create_stack_with_capacity(7);
    cout << "here" << endl;
//    cout << u_create_stack_with_capacity(7)->capacity << endl;
    u_push_stack(stack, tab, stack->capacity);
        cout << " ssssssssssssssssssssssssssssssssssss  " << endl;
    system("pause");
    return 0;
}

Witam, czy mógłby ktoś sprawdzić mi funkcję push? Nie implementowałam wcześniej stosu na wskaźnikach, dlatego proszę o wyrozumiałość. :) btw. w definicji zamiast () są gwiazdki. *

Kod to spory WTF. Co to niby jest "current" i "capacity"? Jaki jest sens ich istnienia, oprócz tego że zajmują kupę miejsca bez celu?

Cała definicja funkcji oraz struktury u_stack_t została narzucona z góry, także zadaniem jest jedynie rozpisanie tych pięciu funkcji tak, aby były poprawne.

No tak ale to struktura dla STOSU, a ja bym tu zrobił dodatkową dla jednego węzła, bo teraz to ma niewielki sens co zrobiłeś.

No ja też średnio widzę w tym sens, dlatego szukam jakiejś pomocy. Bo definicji struktury i funckji właśnie zmieniać nie mogę.

Nie cierpię jak ktoś pisze kod w stylu C, gdy używa tak naprawdę C++, a w tym wypadku C++11 (tam jest zdefiniowany symbol max_align_t).

Skoro masz C++11 to używaj jego zalet. Np unique_ptr i niech ten kod będzie C++, a nie C z dodatkiem C++.

Skoro ktoś kto cię uczy narzucił ci taką formę u_stack_t i taki prototyp funkcji, to cienko wo widzę.

Shalom napisał(a):

Kod to spory WTF. Co to niby jest "current" i "capacity"? Jaki jest sens ich istnienia, oprócz tego że zajmują kupę miejsca bez celu?

(sorry jeśli piszę oczywistość)

Implementacje stosu są co najmniej dwie możliwe.

1. Ta bazująca na CPU / ASM (wersja rosnąca w dół lub w górę - do wyboru, mogą być nawet 3 stosy w jednym bloku pamięci rosnące naprzeciwko i naprzemiennie). Najprostsze wykorzystują blok pamięci, rozmiar i wskaźnik stosu.

2. Bazująca na rozwiązaniu typu linked list.

Ta w OP jest rodzaju (1).

Panowie, spokojnie :) Tak, tak wiem, że ten kod nie jest idealny, zresztą nie jestem nawet programistą. Po prostu dostałam zadanie z którym ciężko mi sobie poradzić i stąd ta prośba o pomoc do mądrzejszych i bardziej doświadczonych.

void *u_push_stack(u_stack_t *stack, void *item, size_t capacity) {
    u_stack_t *newItem = (u_stack_t *)malloc(sizeof(newItem));
    if (newItem) {
    newItem -> store = item;
    newItem -> current = stack -> current;
    stack -> current = newItem;
    stack -> capacity += 1;
    }
}

A mogę po prostu wiedzieć co sądzicie o tej funkcji? Ciężko mi się operuje na wskaźnikach - dotąd moje stosy to były po prostu jakieś inty i już.