CODEWITHSUNDEEP
c++oopmethodsstaticconstants
Kenneth McAusland
Kenneth McAusland

Reputation: 25

Why is the static array member variable showing nothing after calling the instance of the object?

Currently working on Object Oriented Programming in c++ and having problems with an instance showing nothing changed from a method I've created.

The whole code is based off of this object I've created from a header file. 

#ifndef DEQUE_H_
#define DEQUE_H_


#include <iostream>

const int CAPACITY = 5;
const int DEFAULT = -1;

class Deque
{
public:
    Deque();
    int get_size() const;
    bool is_empty() const;
    bool is_full() const;
    int operator[](int i) const;
    static Deque insert_tail(int);
private:
    int size_;
    static int array_[CAPACITY];
};

std::ostream & operator<<(std::ostream &, const Deque &);


#endif

One of the problems I'm having is the insert_tail method that doesn't show any changes to my static array. In the cpp file itself.. these are the function declarations.

#

include <iostream>
#include "Deque.h"

Deque::Deque()
    :size_(0)
{

}
int Deque::array_[5] = {};
int Deque::get_size() const
{
    return size_;
}

bool Deque::is_full() const
{
    if (size_ == 5) return 1;
    else return 0;
}

bool Deque::is_empty() const
{
    if (size_!= 5) return 1;
    else return 0;
}

int Deque::operator[](int i) const
{

    int something = array_[i];
    return something;
}

Deque Deque::insert_tail(int x)
{
    Deque d;
    d.size_ += 1;
    int size = d.size_;
    d.array_[size - 1] = x;

    return d;
}

std::ostream & operator<<(std::ostream & cout, const Deque & dq)
{
    cout << dq.get_size() << " [ ";
    for (int i = 0; i < dq.get_size(); ++i)
    {
        cout << dq[i] << " ";
    }
    cout << "]";

    return cout;
}

The operator works just fine. The bools work just fine and the remove_head and remove_tail thing I'll do once I figure out insert tail. Right now, it's not making any chances to the very object I've created inside the main. 

#include <iostream>
#include "Deque.h"

void print(const Deque & deque)
{
    static int i = 1;
    std::cout << i << ". " << deque << ", empty: " << deque.is_empty()
            << ", full: " << deque.is_full();
    i++;
}

void test_insert_tail(Deque & deque, int x)
{
    deque.insert_tail(x);
    print(deque); std::cout << "\n";
}

int main()
{
    Deque deque;
    print(deque);
    std::cout << "\n";
    test_insert_tail(deque, 2);
    return 0;
}

The output should look like this, 1. 1 [ 2 ], empty: 0, full: 0 but looks like this 1. 0 [], empty: 1, full: 0

What's going on inside my static method for handling all the private attributes that I'm missing on? What did I do wrong exactly?

Upvotes: 2

Views: 68

Answers (1)

Marco Fincato
Marco Fincato

Reputation: 163

The problem with your code is the misuse of the static word. In fact, static means that is not associated with an instance of the object: this means that the content of the static member (the array_ variable in this case) is shared between every instance you will create.

That's the same for the insert_tail method, that can be used even if you don't create an instance. Now, let's try to understand what you've written in this method:

Deque d;
d.size_ += 1;
int size = d.size_;
d.array_[size - 1] = x;
return d;

In the first line, you created a new Deque object. That's the first mistake, cause you're not modifying the actual Deque. Then you add the operations, and in the end, you return the created Deque. However, this object is not saved anywhere, because when you call deque.insert_tail() you aren't assigning the returned value anywhere.

Let's try and get this a little bit more concrete.

Since what you're doing is creating a data structure, you won't need any static member. This because everything needs to be saved inside the data structure.

Then, inside the insert_tail you'll need to remove the object you created inside. It'll look something like this:

size_ += 1;
int size = size_;
array_[size - 1] = x;

With those two modifications the code will probably work as expected, however, I suggest you focus on improving the appearance of your code. Using the underscore character at the end of the variable name is a little bit confusing. In C the only scenario you can use it inside the name int foo_bar for normal variables, and at the beginning int _foo for reserved variables.

Upvotes: 2

Related Questions