在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
热心网友
时间：2024-11-08 22:21
<指向某对象的指针>"->"<该对象当中的成员>
调用的语义：
通过指向某对象的指针来调用该对象当中的成员
该成员可以是方法(函数)，或者某变量
当所指向的对象为派生类时，所调用的成员也可能是其基类的成员
若所调用的成员为虚函数，很有可能调用的是其派生类中的函数
总之，情况不同返回值类型不同
热心网友
时间：2024-11-08 22:24
->的左边是变量，而右边只能是成员，由于不指定所属对象的成员本身不能作为函数参数，所以->的运算符重载函数只能被看作接受一个操作数，其返回的是一个指针（也就是说A->B的时候如果A不是指针，则解释为c->B，其中c是对A调用运算符函数->所返回的指针）
