在C++中,怎么理解“->”是一个单目运算符,它的操作数时什么,返回值又是...

发布网友 发布时间：2024-09-27 07:21

我来回答

共5个回答

热心网友 时间：2024-11-08 22:17

T* operator-> (void) const {

   return &(*(*this));

  }

这是迭代器的形式，说深有点复杂，你现在记住一点：.是对象调用（A.B就是说A是对象，调用A对象中的B，编译器会找到B的地址，如果是函数就调用函数中代码，变量就得到变量值），->是当指针调用（比如

A->B，基本上是把A当作指针在用，虽然有时是类只不过重载了->，但是你这么理解绝对错不了，与.的功能差不多，也是得到地址执行相应代码）。简单的说->左边是指针，.左边是对象

 

下面是链表的模版类，重载了此操作符，希望你能看得懂

// 练习：仿照STL实现一个双向线性链表模板容器

#include <iostream>

#include <stdexcept>

#include <cstring>

using namespace std;

// 链表模板容器

template<class T>

class List {

public:

 // 构造、析构、拷贝构造、拷贝赋值

 List (void) : m_head (NULL), m_tail (NULL) {}

 ~List (void) {

  clear ();

 }

 List (const List& that) :

  m_head (NULL), m_tail (NULL) {

  for (Node* node = that.m_head; node;

   node = node -> m_next)

   push_back (node -> m_data);

 }

 List& operator= (const List& that) {

  if (&that != this) {

   List list (that);

   swap (m_head, list.m_head);

   swap (m_tail, list.m_tail);

  }

  return *this;

 }

 // 获取首元素

 T& front (void) {

  if (empty ())

   throw underflow_error ("链表下溢！");

  return m_head -> m_data;

 }

 const T& front (void) const {

  return const_cast<List*> (this) -> front ();

 }

 // 在首部压入和弹出

 void push_front (const T& data) {

  m_head = new Node (data, NULL, m_head);

  if (m_head -> m_next)

   m_head -> m_next -> m_prev = m_head;

  else

   m_tail = m_head;

 }

 void pop_front (void) {

  if (empty ())

   throw underflow_error ("链表下溢！");

  Node* next = m_head -> m_next;

  delete m_head;

  m_head = next;

  if (m_head)

   m_head -> m_prev = NULL;

  else

   m_tail = NULL;

 }

 // 获取尾元素

 T& back (void) {

  if (empty ())

   throw underflow_error ("链表下溢！");

  return m_tail -> m_data;

 }

 const T& back (void) const {

  return const_cast<List*> (this) -> back ();

 }

 // 在尾部压入和弹出

 void push_back (const T& data) {

  m_tail = new Node (data, m_tail);

  if (m_tail -> m_prev)

   m_tail -> m_prev -> m_next = m_tail;

  else

   m_head = m_tail;

 }

 void pop_back (void) {

  if (empty ())

   throw underflow_error ("链表下溢！");

  Node* prev = m_tail -> m_prev;

  delete m_tail;

  m_tail = prev;

  if (m_tail)

   m_tail -> m_next = NULL;

  else

   m_head = NULL;

 }

 // 删除所有匹配元素

 void remove (const T& data) {

  for (Node* node = m_head, *next; node;

   node = next) {

   next = node -> m_next;

   if (equal (node -> m_data, data)) {

    if (node->m_prev)

     node->m_prev->m_next=node->m_next;

    else

     m_head = node -> m_next;

    if (node->m_next)

     node->m_next->m_prev=node->m_prev;

    else

     m_tail = node -> m_prev;

    delete node;

   }

  }

 }

 // 清空

 void clear (void) {

  for (Node* next; m_head; m_head = next) {

   next = m_head -> m_next;

   delete m_head;

  }

  m_tail = NULL;

 }

 // 判空

 bool empty (void) const {

  return m_head == NULL && m_tail == NULL;

 }

 // 获取元素个数

 size_t size (void) const {

  size_t counter = 0;

  for (Node* node=m_head;node;node=node->m_next)

   counter++;

  return counter;

 }

 // 输出

 friend ostream& operator<< (ostream& os,

  const List& list) {

  for (Node* node = list.m_head; node;

   node = node -> m_next)

   os << *node << ' ';

  return os;

 }

private:

 // 节点

 class Node {

 public:

  Node (const T& data, Node* prev = NULL,

   Node* next = NULL) : m_data (data),

   m_prev (prev), m_next (next) {}

  friend ostream& operator<< (ostream& os,

   const Node& node) {

   return os << node.m_data;

  }

  T     m_data;

  Node* m_prev;

  Node* m_next;

 };

 bool equal (const T& a, const T& b) const {

  return a == b;

 }

 Node* m_head;

 Node* m_tail;

public:

 // 正向迭代器

 class Iterator {

 public:

  Iterator (Node* head = NULL, Node* tail = NULL,

   Node* node = NULL) : m_head (head),

   m_tail (tail), m_node (node) {}

  bool operator== (const Iterator& it) const {

   return m_node == it.m_node;

  }

  bool operator!= (const Iterator& it) const {

   return ! (*this == it);

  }

  Iterator& operator++ (void) {

   if (m_node)

    m_node = m_node -> m_next;

   else

    m_node = m_head;

   return *this;

  }

  const Iterator operator++ (int) {

   Iterator old = *this;

   ++(*this);

   return old;

  }

  Iterator& operator-- (void) {

   if (m_node)

    m_node = m_node -> m_prev;

   else

    m_node = m_tail;

   return *this;

  }

  const Iterator operator-- (int) {

   Iterator old = *this;

   --(*this);

   return old;

  }

  T& operator* (void) const {

   return m_node -> m_data;

  }

  T* operator-> (void) const {

   return &(*(*this));

  }

 private:

  Node* m_head;

  Node* m_tail;

  Node* m_node;

  friend class List;

 };

 Iterator begin (void) {

  return Iterator (m_head, m_tail, m_head);

 }

 Iterator end (void) {

  return Iterator (m_head, m_tail);

 }

};

template<>

bool List<const char*>::equal (const char* const& a,

 const char* const& b) const {

 return strcmp (a, b) == 0;

}

int main (void) {

 int na[] = {10, 20, 30, 20, 50};

 List<int> list1;

 for (size_t i=0; i<sizeof(na)/sizeof(na[0]); i++)

  list1.push_back (na[i]);

 List<int> list2 (list1);

 list2.remove (20);

 List<int> list3;

 list3 = list2;

 list3.remove (30);

 cout << list3 << endl; // 10 50

 cout << list2 << endl; // 10 30 50

 cout << list1 << endl; // 10 20 30 20 50

 char sa[][256] = {"beijing", "shanghai", "tianjin",

  "shanghai", "chongqing"};

 List<string/*const char*/> list5;

 for (size_t i=0; i<sizeof(sa)/sizeof(sa[0]); i++)

  list5.push_front (sa[i]);

 cout << list5 << endl;

 list5.remove ("shanghai");

 cout << list5 << endl;

 cout << "---------------------------" << endl;

 for (List<string>::Iterator it=list5.begin();

  it != list5.end (); it++) {

  (*it)[0] -= 'a' - 'A';

  cout << *it << ' ';

 }

 cout << endl;

 return 0;

}

热心网友 时间：2024-11-08 22:24

-> 是指针运算符之一，它叫 从 被指向的结构成员 查找结构对象指针 的运算。
英文：Structure dereference ("member b of object pointed to by a")， a->b
操作数 是结构成员b， 返回值是 结构对象指针a。句法：a->b

热心网友 时间：2024-11-08 22:22

->的左边是变量，而右边只能是成员，由于不指定所属对象的成员本身不能作为函数参数，所以->的运算符重载函数只能被看作接受一个操作数，其返回的是一个指针（也就是说A->B的时候如果A不是指针，则解释为c->B，其中c是对A调用运算符函数->所返回的指针）

热心网友 时间：2024-11-08 22:21

调用的语法形式：
<指向某对象的指针>"->"<该对象当中的成员>
调用的语义：
通过指向某对象的指针来调用该对象当中的成员
该成员可以是方法(函数)，或者某变量
当所指向的对象为派生类时，所调用的成员也可能是其基类的成员
若所调用的成员为虚函数，很有可能调用的是其派生类中的函数
总之，情况不同返回值类型不同

热心网友 时间：2024-11-08 22:24

没有人解释怎么理解“->”是一个单目运算符？那我来说说我的理解
->的左边是变量，而右边只能是成员，由于不指定所属对象的成员本身不能作为函数参数，所以->的运算符重载函数只能被看作接受一个操作数，其返回的是一个指针（也就是说A->B的时候如果A不是指针，则解释为c->B，其中c是对A调用运算符函数->所返回的指针）