C++ - 我们为什么要使用operator - >来访问SmartPtr的成员函数？
在C++中，我们使用operator->来访问SmartPtr的成员函数，是因为SmartPtr是一种智能指针，它可以自动管理指针的生命周期，避免内存泄漏和悬垂指针的问题。当我们使用operator->来访问SmartPtr的成员函数时，实际上是在调用指针所指向的对象的成员函数。
使用operator->的主要原因是为了简化代码，使得我们可以像操作普通指针一样操作SmartPtr。例如，我们可以使用以下代码来访问SmartPtr的成员函数：
SmartPtr<MyClass> ptr(new MyClass());
ptr->myFunction();这段代码等价于：
SmartPtr<MyClass> ptr(new MyClass());
(*ptr).myFunction();使用operator->可以让我们更方便地操作SmartPtr，而不需要显式地使用*操作符来解引用指针。此外，使用operator->还可以避免多次解引用的问题，从而提高代码的可读性和可维护性。
总之，我们使用operator->来访问SmartPtr的成员函数，是为了简化代码，提高代码的可读性和可维护性，同时避免内存泄漏和悬垂指针的问题。
相关·内容
我试图实现一个类似于标准库auto_ptr的智能指针类，因此我不得不为同样的目的重载->操作符。以下是我的代码
template <typename T>
class SmartPtr
{
T * operator -> ()
{
return _pAct;
}
private:
T * _pAct;
};
实现的其余部分没有显示，以避免从我的查询中转移注意力。
现在我创建了一个类A的SmartPtr，并在它上面调用了一个在A中存在的方法Show()：
SmartPtr smPtr(new A);
smPtr->Show();
这是我
浏览 4提问于2012-10-04得票数 1
回答已采纳
1回答
我正在实现一个简单的智能指针，它基本上跟踪它处理的指针的引用数。
我知道我可以实现移动语义，但我不认为这是有意义的，因为复制一个智能指针非常便宜。特别是考虑到它带来了产生讨厌的错误的机会。
这是我的C++11代码(我省略了一些不必要的代码)。欢迎提出一般性意见。
#ifndef SMART_PTR_H_
#define SMART_PTR_H_
#include <cstdint>
template<typename T>
class SmartPtr {
private:
struct Ptr {
T* p_;
uint64
浏览 1提问于2016-05-07得票数 24
回答已采纳
问题在最后两行代码中给出。
template<class T> // template class for smart
class SmartPtr { // pointers-to-T objects
public:
SmartPtr(T* realPtr = 0);
T* operator->() const;
T& operator*() const;
T* Detach( void )
{
T* pData = pointee;
pointee
浏览 3提问于2011-03-06得票数 1
回答已采纳
6回答
C++协变模板
、、
我觉得这个问题以前有人问过，但我在SO上找不到，在Google上也找不到任何有用的东西。也许“协变”不是我要找的词，但这个概念与函数上的协变返回类型非常相似，所以我认为它可能是正确的。下面是我想要做的事情，它给了我一个编译器错误：
class Base;
class Derived : public Base;
SmartPtr<Derived> d = new Derived;
SmartPtr<Base> b = d; // compiler error
假设这些类都是完全充实的。我想你明白我的意思了。由于不清楚的原因，它不能将SmartPtr<Derive
浏览 2提问于2009-03-12得票数 21
回答已采纳
请考虑下面的代码
// Example program
#include <iostream>
#include <string>
class SmartPtr{
int *ptr;
public:
explicit SmartPtr(int *ptr=0){
ptr = new int;
}
~SmartPtr(){
std::cout<<"Dest is called"<<std::endl;}
int& operator *() /
浏览 0提问于2016-09-11得票数 0
在我的项目中，我的框架中有一些机制，所以我自己设计了C++智能指针。
但是我遇到了智能指针的平等和不平等问题。
class Ref {
public:
void ref(){}
void unref(){}
};
template<class T>
class SmartPtr
{
public:
typedef T element_type;
SmartPtr() : _ptr(nullptr) {}
SmartPtr(T* ptr) : _ptr(ptr) { if (_ptr) _ptr->ref(); }
Smart
浏览 0提问于2019-08-22得票数 3
回答已采纳
2回答
现代C++设计提供了以下示例：
template <class T> struct EnsureNotNull
{
static void Check(T*& ptr)
{
if (!ptr) ptr = GetDefaultValue();
}
};
template
<
class T,
template <class> class CheckingPolicy = EnsureNotNull,
template <class> class ThreadingModel
>
cl
浏览 5提问于2010-08-12得票数 5
回答已采纳
2回答
我在一个网站上看到了这个简单的代码。我没能完全理解。如果有人能一行行地对代码进行分解和解释，这将对我很有帮助。
这是用于创建智能指针模板的代码(自动删除指针是创建此类指针的主要座右铭)。
#include <iostream>
using namespace std;
template <class T>
class SmartPtr {
T* ptr;
public:
explicit SmartPtr(T* p = NULL) {
ptr = p;
}
~SmartPtr() {
delet
浏览 3提问于2017-07-07得票数 0
回答已采纳
2回答
简单智能指针实现的困惑
、、、
下面的代码摘自Packt出版的FedorG.Pikus出版的“<< Hands On Design C++ >>”一书。
几个星期来，有些困惑一直困扰我。
(1)如何初始化char数组mem_？
(2) allocate是否用于分配内存？多么?
(3)为什么mem_ == p？记忆是如何被删除的？
// 02_scoped_ptr.C
// Version 01 with deletion policy.
#include <cstdlib>
#include <cassert>
#include <iostream>
templa
浏览 9提问于2022-07-10得票数 0
回答已采纳
我有一个小问题，为什么我的智能指针类在自我释放时会泄漏。如果我做这样的事情
SmartPtr sp1(new CSine());//CSine is a class that implements IFunction iterface
sp1=sp1;
我的同事告诉我，我的智能指针泄漏了。我在我的智能指针中添加了一些日志消息来跟踪正在发生的事情和一个测试，并报告了以下内容：
SmartPtr sp1(new CSine());
->CSine constructor
->RefCounter increment 0->1
->RefCounter constructor
浏览 3提问于2009-12-03得票数 1
回答已采纳
可能重复：
这两者有什么区别呢？你什么时候用一种代替另一种？
有一次我试着用'->‘而不是’‘.我得到了“左操作数有'class‘类型，使用'.'”错误，这是什么意思？
浏览 7提问于2011-09-08得票数 1
回答已采纳
2回答
我有自己的智能指针类实现。
template<class Pointee>
class SmartPtr {
private:
Pointee* _pointee;
SmartPtr(SmartPtr &);
public:
explicit SmartPtr(Pointee * pt = 0);
~SmartPtr();
SmartPtr& operator=(SmartPtr&);
operator Pointee*() const { return _pointee; }
bool operato
浏览 0提问于2017-10-07得票数 1
回答已采纳
3回答
为什么这样做效果很好：
cout << "foo";
而这不是吗？
(&cout)->operator<<("foo");
它可以很好地处理数值，所以我猜它与override有关。(我使用的是MS Visual C++编译器。)
浏览 0提问于2012-04-07得票数 3
回答已采纳
5回答
我是C++的新手，还在努力掌握它的语法。我已经看了几个操作符重载的例子，最近的智能指针实现。下面是我正在查看的一个非常通用的示例：
template < typename T > class SP
{
private:
T* pData; // Generic pointer to be stored
public:
SP(T* pValue) : pData(pValue)
{
}
~SP()
{
delete pData;
}
T& operator* ()
浏览 1提问于2014-02-05得票数 40
3回答
什么操作员在这里超载了？
operator T * ()
我知道操作符方法有以下结构：
type operator operator-symbol ( parameter-list )
假设我们有以下代码
template<typename T> class SmartPtr
{
public:
SmartPtr(T* data): member(data) {}
T* member;
T& operator * () { return *member; } //usage: *TObj
T*& operator
浏览 0提问于2014-01-29得票数 3
回答已采纳
1回答
我正在努力提高C++的一般技能，所以我计划从头开始编写shared_ptr和unique_ptr的版本。我写了一个带有参考计数的shared_ptr版本，我想要得到评论。
#ifndef __SHIVA_XSMARTPTRS__
#define __SHIVA_XSMARTPTRS__
/*
This tries to define a reference counted smart pointer class instead of
regular pointers
*/
namespace Shiva
{
template <class T>
class SmartPtr
{
浏览 0提问于2017-01-11得票数 2
我试图重载<<操作符，这样当我在std::cout中使用我的类对象时，它会打印出应该打印的数据成员。我知道我必须在类内定义一个朋友函数签名，然后在类外定义两个朋友函数来做这项工作，但我想移交类，而不是让用户做任何事情，我想让类处理所有的事情。如何在c++中实现这样的功能？
提前谢谢你
浏览 0提问于2012-04-17得票数 0
回答已采纳
1回答
类内类的访问方法
、、
我正在尝试将一些代码从旧版本的程序移植到新版本，但有些东西已经移动了。有一个名为' Game‘的类，它曾经包含一个名为ButtonNameToIndex的方法，但是在新版本中，在游戏类中有一个名为' InputScheme’的类，并且ButtonNameToIndex是在InputScheme中声明的
Game.h：
class Game
{
public:
const char * m_szName;
const Style * const* m_apStyles;
bool m_bCountNotesSeparately;
b
浏览 2提问于2012-11-08得票数 0
回答已采纳
2回答
我将一些图像复制到c++中的向量中。现在我在某个地方需要同样的垫子。我将如何从push_back中获取数据。请帮帮我。这是密码的一部分.
for (ic = 0; ic < images.size(); ic++)
{
roi_b.x = images[ic].x;
roi_b.y = images[ic].y;
roi_b.width = (images[ic].width);
roi_b.height = (images[ic].height);
crop = image(roi_b
浏览 4提问于2015-02-23得票数 0
回答已采纳
我有一个基类，它包含数组并提供一个简单的operator[]：
class Object
{
public:
std::shared_ptr<Object> operator[](const int index);
[...]
private:
std::vector<std::shared_ptr<Object>> internal_array;
};
当我想直接访问操作符而不取消引用时，我的编译器(MSVC 2017)不喜欢这样：
std::shared_ptr<Object> one_object;
std::s
浏览 0提问于2018-01-21得票数 0
回答已采纳
4回答
以前，我学习过在C++中重载操作符作为类的成员函数和朋友函数。不过，我知道如何使用这两种技术在C++中重载操作符。但是我仍然很困惑，哪一个更好？一个成员函数或一个用于重载操作符的朋友函数，我应该使用哪一个?为什么？请指引我！您的答复将不胜感激。我将对你的回答感到高兴和感激。
浏览 5提问于2017-03-29得票数 14
回答已采纳
假设你有一个这样的函数：
SmartPtr<A> doSomething(SmartPtr<A> a);
像这样的类：
class A { }
class B : public A { }
现在我这样做：
SmartPtr<A> foo = new B();
doSomething(foo);
现在，我想从doSomething取回一个SmartPtr<B>对象。
SmartPtr<B> b = doSomething(foo);
有可能吗？我需要做什么样的选角？
现在，我发现了一些我认为丑陋的东西：
B* b = (B*)doSo
浏览 1提问于2011-04-12得票数 4
回答已采纳
为了说明c++中的重载，我为我的一位学生同事编写了这个小代码：
#include <iostream>
int main() {
std::cout << "Hello World!";
std::cout.operator<<("Hello World!");
return 0;
}
我天真地以为我会有两次“你好世界！”但第二行给我发了封信。我不明白为什么？
浏览 4提问于2021-02-19得票数 10
回答已采纳
我刚刚从领英学习完成了c++基本培训，现在我有一个简单的问题。为什么cout会输出，我们只是在调用对象，但是为什么仅仅调用一个对象就能做一些事情。我的猜测是'<<‘重载运算符执行某些操作，但随后出现了'<< std:: endl ;’，对于endl，我们再次只是调用对象，但它创建了一个新的行。
浏览 0提问于2021-04-14得票数 2
1回答
我有两个类，A和B，B是从A派生的。我不允许更改它们。我正在实现智能指针类。
template <typename T>
class SmartPtr{
...
SmartPtr& operator=(const SmartPtr& p);
...
}
template<typename T>
SmartPtr<T>& SmartPtr<T>::operator=(const SmartPtr & p) {
++*p.cnt;
if(--*cnt == 0) {
浏览 1提问于2015-06-04得票数 0
2回答
我做了一个引用计数智能指针类。我的目标是用适当的文档创建一个“最小”但“通用”的智能指针类。这基本上是为了教育目的。
我想有一些关于异常处理、代码清晰性、注释、API的易用性等方面的评论，如果代码是“工业级别”的话，我也会发表评论。
#ifndef SMARTPTR_HPP
#define SMARTPTR_HPP
#include <algorithm>
namespace smartptrnamespace
{
//
// Basic reference counting smart pointer (no overloaded Bool magic, etc).
//
浏览 0提问于2013-04-18得票数 3
我看到了std::array的实现，其中所有成员都是public。然而，并不意味着通过引用其名称直接访问基础数组(或任何类型的数据成员)。我知道访问该成员的标准方式是通过std::array::data()。
是否有国际标准化组织C++标准的规范描述了通过引用其名称直接访问底层数据成员的尝试？
让我们假设基础public数据成员是一个固定大小的数组，它的名称是_data。
std::array<char, 10> a{};
a._data[0] = 'A';
ISO C++标准如何描述第二条语句？这是未定义的行为吗？没有具体说明？
浏览 1提问于2021-03-06得票数 1
嗨(英语不是我的第一语言，即使我犯了错，也请理解我！)谢谢！
我正在编写一个模板类，它可以包含一个指针。
template <typename T>
class SmartPtr {
private:
T value;
public:
SmartPtr() {};
~SmartPtr() {};
SmartPtr(T* a)
{
this->value = *a;
}
SmartPtr(SmartPtr* a)
{
this->value = a-
浏览 1提问于2017-10-17得票数 0
回答已采纳
我偶然发现了这个代码(这里的简化版本)：
template<typename T>
class SmartPtr;
template<typename T>
struct SmartPtr<const T>
{
const T& operator*() const { return *_ptr; }
const T* operator->() const { return _ptr; }
const T* _ptr;
// more mem
浏览 1提问于2021-11-30得票数 5
回答已采纳
1回答
c++成员函数隐藏全局函数
、、、、
此代码段不编译：
struct M {
int i;
int j;
};
void f(M& m) {
m.i++;
}
struct N {
M m;
void f(int i) {
f(m); // compilation error
}
};
clang说：No viable conversion from 'M' to 'int'似乎是我的成员函数隐藏的全局函数。
我将错误行更改为::f(m)以帮助名称解析，但仍然失败。这是否意味着在c++成员函数中，不能调用同名但不同参数列表的
浏览 7提问于2022-09-03得票数 -2
回答已采纳
9回答
C++语法允许在结构/类中定义重载操作符，如下所示：
struct X
{
void operator+(X);
}
或者在结构/类之外，如：
void operator+(X, X);
但不是像
struct X
{
static void operator+(X, X);
}
有没有人知道做出这个决定的原因？为什么不允许第三种形式？(MSVC给出语法错误)。也许这背后有什么故事？
附注：第一个和第二个定义同时存在会造成歧义：
1>CppTest1.cxx
1>c:\ballerup\misc\cf_html\cpptest1.cxx(39) : error C259
浏览 19提问于2012-08-10得票数 46
回答已采纳
2回答
我正在学习C++，特别是操作符重载。
我有以下代码：
#include <iostream>
#include <string>
using namespace std;
class Vector2
{
private:
float x, y;
public:
Vector2(float x, float y)
: x(x), y(y) {}
Vector2 Add(const Vector2& other) const;
Vector2 operator+(const Vector2& other)
浏览 3提问于2021-06-19得票数 0
回答已采纳
1回答
嵌套智能指针操作符->
、、、
我有自己的智能指针类实现。
template<typename Pointee>
class SmartPtr {
private:
Pointee* _pointee;
SmartPtr(SmartPtr &);
public:
explicit SmartPtr(Pointee * pt = 0);
~SmartPtr();
SmartPtr& operator=(SmartPtr&);
operator Pointee*() const { return *_pointee; }
bool ope
浏览 1提问于2017-10-07得票数 1
6回答
我正在自学c++。我学习操作者超载，我能够理解加减法操作符过载。但是I/O操作符的重载有点让人困惑。我已经为复数创建了一个类，现在我是重载操作符。
Complex.h中的功能原型
friend ostream& operator<<(ostream&, const Complex&);
函数来自Complex.cpp
ostream& operator<<(ostream& os, const Complex& value){
os << "(" << value.r <<
浏览 0提问于2014-07-13得票数 4
回答已采纳
我对为自定义类实现迭代器感到困惑。我正在尝试为std::set实现一个迭代器，将我的顶点类声明为：
class Vertex{
public:
int i, j;
std::set<Vertex*> adj; //references to adjacent vertices
Vertex();
~Vertex();
//end constructors
/** must overload for set<Vertex&g
浏览 2提问于2015-01-04得票数 1
回答已采纳
为什么我要重载C++运算符()作为全局函数而不是成员函数。例如，==操作符。
为什么要这样做？例如在STL库中。
浏览 1提问于2011-09-28得票数 5
回答已采纳
1回答
我有一个模板化的类，在这个类中，我需要为同样被模板化的类专门化几种方法。更确切地说:我尝试将智能数组和共享指针组合起来：
template <class T>
int sortedArray< smartPtr<T> >::insert(const T& object) {
...
}
使用这种语法，我得到以下错误：
main.cpp:162:55: error: invalid use of incomplete type ‘class sortedArray<smartPtr<T> >’
int sortedArray&l
浏览 2提问于2015-04-15得票数 2
回答已采纳
因此，我正在尝试创建一个基类，它对这类基类具有默认的去分配函数。根据我删除派生对象的方式，我看到了不同的行为，也许任何人都可以解释为什么我没有看到我的重写在以下注释的情况下工作，在这种情况下，自定义取消分配没有被调用：
#include <iostream>
struct B {
void operator delete(void* ptr) {
std::cout << "B's operator delete" << std::endl;
::operator delete(ptr);
浏览 0提问于2019-04-08得票数 3
回答已采纳
2回答
我试图用同样的方法重载运算符'=‘和'<<’。
class Vect{
public:
//..
Vect& operator=(const Vect& a);
ostream& operator<<(ostream& out, const Vect& vect);
//..
private:
int *data;
int size;
};
这项工作
Vect& Vect:: operator=(const Vect& a){
//..
//copy
浏览 4提问于2015-11-17得票数 1
在他的书中，费多尔·G·皮库斯谈到了C++中的类型擦除。具体来说，他提到了一个智能指针的例子，它有自己的删除器，其类型是“抽象离开”。
这就是他的例子：
template <typename T>
class smartptr {
struct deleter_base {
virtual void apply(void*) = 0;
virtual ~deleter_base() { }
};
template <typename Deleter>
struct deleter : public de
浏览 6提问于2022-09-11得票数 0
1回答
朋友函数及其与I/O算子的关系
、、、、
我仔细研究了有关朋友功能及其使用的信息。它们能够访问类中封装的数据，同时不破坏OOP的黄金规则之一。在提供各种用于重载I/O操作符的源代码时(一个基本操作，学习C++的第一个教授之一)，每个人都将操作符定义为朋友，作为类之外的实现。我的问题是:是否需要这样做？为什么不将函数声明为类的公共成员，并从类中插入/显示数据，同时将所有内容封装起来？这似乎与重载其他运营商没有什么不同，但这是一种传统的过载I/O操作的方法。
耽误您时间，实在对不起。
浏览 1提问于2013-04-29得票数 0
回答已采纳
4回答
在C++ Primer 13.5.1书中，它使用使用使用计数类实现了一个智能指针类.它们的执行情况如下：
使用-计数级
//专用类，仅供HasPtr类U_Ptr {朋友类HasPtr；int *ip；size_t use；U_Ptr(int *p)：ip(p)，use(1) {} ~U_Ptr() { delete ip；}；
智能指针类
/*智能指针类:获取它绑定到的动态分配对象的所有权，用户代码必须动态分配对象以初始化HasPtr，并且不能删除该对象；HasPtr类将删除它*/类HasPtr { public: // HasPtr拥有指针；P必须是动态分配的HasPtr(int *
浏览 4提问于2014-01-03得票数 6
回答已采纳
以下面的代码为例：
template<class Derived>
struct base {
Derived operator++(int){
auto tmp = static_cast<Derived &>(*this);
++static_cast<Derived &>(*this);
return tmp;
}
};
struct der : public base<der> {
der &operator++(){
ret
浏览 0提问于2019-03-17得票数 1
回答已采纳
3回答
我是c++的新手。
#include<cstdio>
#include<string>
using namespace std;
class add{
public :
int a,b;
add();
add(int ,int);
add operator+(add);
};
add::add():a(0),b(0){};
add::add(int x,int y):a(x),b(y){};
add add::operator+(add z)
{
add temp;
temp.a=a+z.a;
temp.b=b+
浏览 0提问于2013-10-05得票数 0
回答已采纳
stockListType.cpp:58:从此处实例化
/usr/include/c++/4.2.1/bits/stl_algo.h:91: error: passing ‘const stockType’ as ‘this’ argument of ‘bool stockType::operator<(const stockType&)’ discards qualifiers
/usr/include/c++/4.2.1/bits/stl_algo.h:92: error: passing ‘const stockType’ as ‘this’ argument of ‘bo
浏览 2提问于2013-09-29得票数 15
4回答
为什么C++没有直接对应位置新建的位置删除，即调用析构函数并调用相应的位置删除操作符？
例如：
MyType *p = new(arena) MyType;
...
//current technique
p->~MyType();
operator delete(p, arena);
//proposed technique
delete(arena) p;
浏览 0提问于2011-05-02得票数 35
回答已采纳
对于C++中的闭包是什么，我一直很困惑。我读过这个，但是几乎所有的答案都提到了JavaScript，但是我认为C++和JavaScript之间的闭包有一些不同。因此，我发现很难将JavaScript描述的闭包与C++匹配。
例如，几乎所有的答案都以返回函数的函数为例，在JavaScript中演示闭包。但我在C++中找不到类似的模式。
更重要的是，在JavaScript中没有所谓的“捕获列表”。
I被告知，如果一个函数使用非局部变量(来自外部范围或全局范围)，那么它就是一个闭包。对吗？
示例1：
int a = 3;
int am_I_a_closure(int c){
浏览 1提问于2020-05-05得票数 2
回答已采纳
1回答
根据Deitel的“9 9ed C++ How to program”，第444页：
为什么重载的流插入和流提取操作符被重载为非成员函数
重载流插入运算符( << )用于左操作数具有ostream类型的表达式&如cout << classObject。若要以这种方式使用操作符，而右操作数是用户定义类的对象，则必须将其重载为非成员函数。要成为成员函数，操作符<<必须是类ostream的成员。这对于用户定义的类是不可能的，因为我们不允许修改C++标准库类。
问题是<<已经是ostream的成员了。它到底在说什么？我是不是遗漏了什么？
浏览 1提问于2018-04-15得票数 2
我试过以下几种方法，但不起作用。为什么？
std::string s = "hello" + "world";
为什么C++标准库开发人员决定不重载operator+来实现char*连接？难道这不会使人们的生活变得简单吗？
浏览 5提问于2017-07-11得票数 3
回答已采纳
有谁能解释一下它们之间的区别：
const char& operator[] const
和
char& operator[]
在C++？第二个是不是真的在复制字符串？为什么？
浏览 0提问于2011-09-25得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
