References: I need a quick bit of help.

All,

   Thanks to anyone who reads this. I am trying to implement a basic
dictionary class using a binary tree. That information is fairly
unimportant as I'm simply trying to use references to contain the node
data. When i create my tree, create it's root node, and then try to
return the data, it comes back as either garbled or the wrong data. I
have attached all of my code, any help is appreciated.

binNode.h
----------------

#ifndef BINNODE_H
#define BINNODE_H

class binNode
{ public:
    binNode(binNode* left,float& item,binNode* right);
    void setLeftChild(binNode* aChild);
    void setRightChild(binNode* aChild);
    binNode* left() const; // left child
    binNode* right() const; // right child
    float& nodeData() const; // current node data
  private:
    binNode* lchild;
    float& data;
    binNode* rchild;
};

#endif
-------------------

binNode.cc
-------------------
#include <iostream>
#include "binNode.h"

binNode::binNode(binNode* left,float& item,binNode* right) : data(0) {

  if (left!=0) {
    lchild = left;
  } else {
    lchild = 0;
  }

  if (right!=0) {
    rchild = right;
  } else {
    rchild = 0;
  }

  data = item;

  cout << "!" << data << endl;
  cout << item << endl;
  return;
}

void binNode::setLeftChild(binNode* aChild) {
  if (aChild!=0) {
    lchild = aChild;
  }
  return;
}

void binNode::setRightChild(binNode* aChild) {
  if (aChild!=0) {
    rchild = aChild;
  }

  return;
}

binNode* binNode::left() const {
  return lchild;
}

binNode* binNode::right() const {
  return rchild;
}

float& binNode::nodeData() const {
  cout << "!!" << data << endl;

  return data;
}

-------------------------
dict.h
-------------------------
#ifndef DICT_H
#define DICT_H

#include "binNode.h"

class dict
{ public:
    dict();
    ~dict();
    void insert(float& obj);
    float& remove(const float& key);
    float& search(const float& key) const;
    void inorder() const;
  private:

    binNode* root;
};

#endif

-------------------------
dict.cc
-------------------------
#include "dict.h"
#include <iostream>

dict::dict() {

  root = 0;

  return;
}

dict::~dict() {
  return;
}

void dict::insert(float& obj) {
  float val = 0;
  float& ref = val;

  if (root==0) {

    cout << "Creating root with value: " << obj << endl;

    root = new binNode(0,obj,0);

    ref = root->nodeData();

    cout << "After creation: " << &ref << endl;

  } else {
    cout << "Need to create a child!" << endl;
    if(root->nodeData()>=obj) {
      cout << "Bigger than or equal to" << endl;
    } else {
      cout << "Less than" << endl;
    }
  }

  return;
}

float& dict::remove(const float& key) {
  return 0.0;
}

float& dict::search(const float& key) const {
  return 0.0;
}

void dict::inorder() const {
  cout << "Address: " << root << endl;
  cout << root->nodeData();
  return;
}
--------------------

main.cc
--------------------
#include "dict.h"
#include <iostream>

void main(void) {

  float value1 = 5.0;
  dict *myDict;

  myDict = new dict();

  myDict->insert(value1);

  return;
}
--------------------

Output
--------------------
Creating root with value: 5 <- creation statement
!5 <- Value of the class private variable after creation
5 <-Value of the argument passed to the function
!!1.08526e-19 <-value when attempted to return by root->nodeData();
After creation: 0x11fffbfc8 <-Address of the reference, i was trying
to compare them
--------------------

Once again,
any help is appreciated.

Thanks,
Ken