指向的打印对象

Question

I try to print values from my object class, but I am unable to properly access the information stored at the pointer. Below I have defined a simple struct.

When compiled, I get an error:

no match for 'operator<<' (operand types are 'std::ostream {aka std::basic_ostream<char>}' and 'std::vector<int>')

void PrintNode(Node *node) { cout << node->key << endl; }

struct Node
{
    vector<int> key;
    int parent; 
    Node(vector<int> x, int y){ key = x; parent = y; }
    void PrintNode(Node* node) { cout << node->key << endl; }
};

I call my PrintNode in my BFS function:

void BFS( vector<int> permutation, int n ) {
    vector<Node*>Pointers;
    queue<Node*> Queue;
    Node* start = new Node(permutation, -1);
    Node::PrintNode( start );
    Pointers.push_back( start );
}

I don't understand why I am unable to cout the integer vector stored in .key of the node object. I believe that I am dereferencing the pointer correctly with node->key .

Answer 1

The standard library doesn't support direct iostreams output of a vector . But you can easily define such an operation. Just do it with a loop.

Answer 2

std::cout cannot handle raw vectors, you must convert it to an array which is can process first. You can do this using vector 's .data() method

Example:

void PrintNode(Node* node) { cout << node->key.data() << endl; }

Answer 3

I try to print values from my object class, but I am unable to properly access the information stored at the pointer. Below I have defined a simple struct.

The simple answer to this question is the fact that std::vector<type, allocator> does not have an overload for the std::ostream::<< operator. Hence when you try to print out the entire vector of keys, it won't work the way you expect it to. I have seen several answers on other posts which suggest overloading the << operator for std::vector but unless you know what you are doing I would avoid doing this for several reasons, one of them being global namespace pollution and the second being incorrect handling of the overloading itself.

Also, please stop doing using namespace std; . It will not help you in any way and just make things worse in the most unexpected ways.

Here are some fixes which may help.

Part 1 - Node struct

struct Node : public std::enable_shared_from_this<Node>
{
    std::vector<int> keys;
    int parent; 
    Node(vector<int> x, int y) : keys(x), parent(y){}
    Node(const Node& rhs): keys(rhs.keys), parent(rhs.parent) {}
    Node(Node&& rhs) noexcept: keys(std::move(rhs.keys)), parent(rhs.parent){}
    
    void PrintNode()
    {
        for (auto& key : node->keys)
            cout << key << "\n";
    }
};

Part 2 BFS Code

void BFS(std::vector<int>& permutation, int n )
{
    /* I don't see the real value in creating pointers for your case. You can easily live with an instance of the class Node. This also gives you scoped initialization as the pointers vector goes out of scope, your nodes will get deallocated too. at least in the context, you have posted above, that seems desirable.
However, if you insist on creating pointers, you can use smart pointers.
*/
    std::vector<std::shared_ptr<Node>> pointers;
    std::queue<std::shared_ptr<Node>> queue; // not used??
    auto start = std::make_shared<Node>(permutation, -1); // make a shared pointer
/* PrintNode in your code is an instance level function. Invoke it using the scope resolution operators . or ->. If you insist on doing it your way, then declare the function static. However, that has its own quirks and you need to understand static functions before you do this. */
    start->PrintNode(); 
    pointers.push_back(std::move(start)); // add your pointer to the vector.
}

That said the code excerpt you have posted makes little sense. I have just provided fixes for the parts you have provided. Does not guarantee that it will work in the larger context you may have at hand.