为什么用C ++编码时不建议使用指针？

我从某处了解到，在使用C ++时，建议不要使用指针。在使用C ++时，为什么指针这么不好？对于习惯使用指针的C程序员，C ++中更好的替代方法是什么？

我认为它们意味着您应该使用智能指针而不是常规指针。

在计算机科学中，智能指针是一种抽象的数据类型，它在提供附加功能（例如自动垃圾收集或边界检查）的同时模拟指针。这些附加功能旨在减少因滥用指针而导致的错误，同时保持效率。智能指针通常会跟踪它们指向的对象，以进行内存管理。

指针的滥用是错误的主要来源：使用指针编写的程序必须执行的常量分配，释放和引用会带来内存泄漏的风险。智能指针试图通过使资源自动分配来防止内存泄漏：当对象的指针（或一系列指针中的最后一个）被破坏时（例如，由于超出范围，则指向的对象也被破坏）。

在C ++中，重点将放在垃圾回收和防止内存泄漏（仅举两个）上。指针是语言的基本组成部分，因此除了最普通的程序之外，几乎不使用指针是不可能的。

由于我是发表论战性的“不要使用fcking指针”的人，所以我觉得我应该在这里发表评论。

首先，作为争论，它显然代表了一种极端的观点。有是肯定的（原始）指针合法用途。但是我（和许多专业的C ++程序员）坚持认为，这种情况极为罕见。但是，我们真正的意思是：

第一：

原始指针在任何情况下都不得拥有自己的内存。

在这里，“自己的内存”本质上是指在某个时候delete在该指针上调用了它（但是比它更笼统）。该声明可以放心地认为是绝对的。该只实现自己的智能指针（或其他存储管理策略）时的例外是。即使在那儿，您通常仍应在低级别使用智能指针。

这样做的理由很简单：拥有内存的原始指针会引入错误源。这些错误在现有软件中是多产的：内存泄漏和重复删除-两者都是资源所有权不明确的直接结果（但方向相反）。

只需使用智能指针而不是原始指针，就可以完全免费地彻底解决此问题（注意：当然，这仍然需要思考；共享指针可能导致循环，从而再次导致内存泄漏，但这很容易可以避免）。

第二：

在C ++中，大多数指针的使用都是不必要的。

与其他语言不同，C ++对值语义有很强的支持，并且根本不需要指针的间接调用。并没有立即意识到这一点–历史上，C ++的发明是为了促进C语言中轻松的对象定向，并且在很大程度上依赖于构建通过指针连接的对象图。但是在现代C ++中，这种范例很少是最佳选择，并且现代C ++习惯用法通常根本不需要指针。它们对值而不是指针进行操作。

不幸的是，此消息仍未在C ++用户社区中流行。结果，大多数编写的C ++代码仍然充满了多余的指针，这使代码变得复杂，缓慢，错误/不可靠。

对于了解现代C ++的人来说，很明显，您很少需要任何指针（智能指针或原始指针；除非将它们用作迭代器）。生成的代码更短，更简单，更易读，通常更高效，更可靠。

仅仅是因为有一些可用的抽象，这些抽象隐藏了使用指针的更多气质，例如访问原始内存和在分配后进行清理。使用智能指针，容器类和RAII之类的设计模式，就可以减少使用原始指针的需要。就是说，就像任何抽象一样，您应该先了解它们的实际工作方式，然后再超越它们。

相对而言，C的心态是“遇到问题了？使用指针”。您甚至可以在C ++早期使用成员指针的情况下，在C字符串，函数指针，指针作为迭代器，指针对指针，空指针中看到这一点。

但是在C ++中，您可以将值用于许多或所有这些任务。需要功能抽象吗？std::function。这是一个功能的价值。std::string？这是一个值，那是一个字符串。您可以在C ++上看到类似的方法。这使得对人类和编译器的代码分析变得非常容易。

原因之一是指针的应用范围太广。它们可用于在容器上进行迭代，避免在传递给函数时复制大型对象，非平凡的生命周期管理，访问内存中的随机位置等。一旦将它们用于一个目的，它们的其他功能就会变得可用立即立意独立。

选择特定用途的工具可使代码更简单，意图更清晰-迭代程序的迭代器，生命周期管理的智能指针等。

除了已经列出的原因之外，还有一个显而易见的原因：更好的优化。在使用指针算术的前提下，混淆分析过于复杂，而引用则暗示了一个优化器，因此，如果仅使用引用，则可能进行更深入的混淆分析。

除了@jmquigley指出的内存泄漏风险外，还可以认为指针和指针算法存在问题，因为指针可以指向内存中的所有位置，从而导致“难以发现错误”和“安全漏洞”。

这就是为什么它们几乎被C＃和Java弃用的原因。

C ++支持大多数C语言，功能以及对象和类。C已经有了指针和其他东西。

指针是一种非常有用的技术，可以与“对象定向”结合使用，并且C ++支持它们。但是，这种技术难以教导并且难以理解，并且非常容易引起不需要的错误。

许多新的编程语言假装不对对象使用指针，例如Java，.NET，Delphi，Vala，PHP，Scala。但是，仍在“幕后”使用指针。这些“隐藏指针”技术称为“引用”。

无论如何，我将指针视为一种编程模式，是解决某些问题的一种有效方法，而面向对象编程也是如此。

其他开发人员可能有不同的意见。但是，我建议学生和程序员学习如何：

（1）使用无对象的指针

（2）无指针的对象

（3）对象的显式指针

（4）指向对象的“隐藏”指针（AKA 参考）；-)

以该顺序。

即使很难教，也很难学习。对象Pascal（Delphi，FreePascal等）和C++（非Java或C＃）可用于这些目标。

而且，后来的新手程序员可以转而使用“隐藏的对象指针”编程语言，例如Java，C＃，面向对象的PHP等。

关于VC6，当您将类的实例（实例化）转换为变量（例如DWORD）时，即使该指针是本地的，也可以通过使用同一堆的所有函数访问该类。实例化的类被定义为本地，但实际上不是。据我所知，堆变量，结构或类的任何地址在宿主类的整个生命周期中都是唯一的。

例：

class MyClass1 {
    public:
        void A (void);
        void B (void);
        void C (void);
    private:
        DWORD dwclass;
};

class MyClass2 {
    public:
        int C (int i);
};

void MyClass1::A (void) {
    MyClass2 *myclass= new MyClass2;
    dwclass=(DWORD)myclass;
}

void MyClass1::B (void) {
    MyClass2 *myclass= (MyClass2 *)dwclass;
    int i = myclass->C(0); // or int i=((MyClass2 *)dwclass)->C(0);
}

void MyClass1::B (void) {
    MyClass2 *myclass= (MyClass2 *)dwclass;
    delete myclass;
}

编辑那是原始代码的一小部分。CSRecodset类只是CXdbRecordset的强制转换类，所有真实代码都在其中。这样一来，我可以让用户从我写的内容中受益，而不会失去我的权利。我不假装证明我的数据库引擎是专业的，但它确实有效。

//-------------------------------------
class CSRecordSet : public CSObject
//-------------------------------------
{
public:
    CSRecordSet();
    virtual ~CSRecordSet();
    // Constructor
    bool Create(CSDataBase* pDataBase,CSQueryDef* pQueryDef);
    //Open, find, close
    int OpenRst(bool bReadBlanks=0,bool bCheckLastSql=0,bool bForceLoad=0,bool bMessage=1);     // for a given SQL
    int FindRecord(bool bNext);         // for a given SQL
    // TABLE must be ordered by the same fields that will be seek
    bool SeekRecord(int nFieldIndex, char *key, int length=0);  // CRT bsearch
    bool SeekRecord(int nFieldIndex, long key);     
    bool SeekRecord(int nFieldIndex, double key, int decimals);     
    bool SeekRecord(XSEK *SEK);     
    bool DeleteRecord(void);
    bool Close(void);
    // Record Position:
    bool IsEOF(void);           // pointer out of bound
    bool IsLAST(void);          // TRUE if last record
    bool IsBOF(void);           // pointer out of bound
    bool IsOpen(void);
    bool Move(long lRows);      // returns FALSE if out of bound
    void MoveNextNotEof(void);  // eof is tested
    void MoveNext(void);        // eof is not tested
    void MovePrev(void);        // bof is tested
    void MoveLast(void);
    void MoveFirst(void);
    void SetAbsolutePosition(long lRows);
    long GetAbsolutePosition(void);
    void GoToLast(void); // Restore position after a Filter
    // Table info
    long GetRecordCount(void);
    int GetRstTableNumber(void);
    int GetRecordLength(void); //includes stamp (sizeof char)
    int GetTableType(void);
    // Field info
    int GetFieldCount(void);
    void GetFieldName(int nFieldIndex, char *pbuffer);
    int GetFieldIndex(const char *sFieldName);
    int GetFieldSize(int nFieldIndex);
    int GetFieldDGSize(int nFieldIndex); // String size (i.e. dg_Boolean)
    long GetRecordID(void);
    int GetStandardFieldCount(void);
    bool IsMemoFileTable(void);
    bool IsNumberField(int nFieldIndex);
    int GetFieldType(int nFieldIndex);
    // Read Field value
    bool GetFieldValue(int nFieldIndex, XdbVar& var);
    bool GetFieldValueIntoBuffer(int nFieldIndex,char *pbuffer);
    char *GetMemoField(int nMemoFieldIndex, char *pbuffer, int buf_size);
    bool GetBinaryField(unsigned char *buffer,long *buf_size);
    // Write Field value
    void Edit(void); // required
    bool SetFieldValue(int nFieldIndex, XdbVar& var);
    bool SetFieldValueFromBuffer(int nFieldIndex,const char *pbuffer);
    bool Update(void); // required
    // pointer to the same lpSql
    LPXSQL GetSQL(void);
};

//---------------------------------------------------
CSRecordSet::CSRecordSet(){
//---------------------------------------------------
    pClass |= (CS_bAttach);
}
CSRecordSet::~CSRecordSet(){
    if(pObject) delete (CXdbRecordset*)pObject;
}
bool CSRecordSet::Create(CSDataBase* pDataBase,CSQueryDef* pQueryDef){
    CXdbQueryDef *qr=(CXdbQueryDef*)pQueryDef->GetObject();
    CXdbTables *db=(CXdbTables*)pDataBase->GetObject();
    CXdbRecordset *rst = new CXdbRecordset(db,qr);
    if(rst==NULL) return 0;
    pObject = (unsigned long) rst;
    return 1;
}
bool CSRecordSet::Close(void){
    return ((CXdbRecordset*)pObject)->Close();
}
int CSRecordSet::OpenRst(bool bReadBlanks,bool bCheckLastSql,bool bForceLoad, bool bMessage){
    unsigned long dw=0L;
    if(bReadBlanks) dw|=SQL_bReadBlanks;
    if(bCheckLastSql) dw|=SQL_bCheckLastSql;
    if(bMessage) dw|=SQL_bRstMessage;
    if(bForceLoad) dw|=SQL_bForceLoad;

    return ((CXdbRecordset*)pObject)->OpenEx(dw);
}
int CSRecordSet::FindRecord(bool bNext){
    return ((CXdbRecordset*)pObject)->FindRecordEx(bNext);
}
bool CSRecordSet::DeleteRecord(void){
    return ((CXdbRecordset*)pObject)->DeleteEx();
}
bool CSRecordSet::IsEOF(void){
    return ((CXdbRecordset*)pObject)->IsEOF();
}
bool CSRecordSet::IsLAST(void){
    return ((CXdbRecordset*)pObject)->IsLAST();
}
bool CSRecordSet::IsBOF(void){
    return ((CXdbRecordset*)pObject)->IsBOF();
}
bool CSRecordSet::IsOpen(void){
    return ((CXdbRecordset*)pObject)->IsOpen();
}
bool CSRecordSet::Move(long lRows){
    return ((CXdbRecordset*)pObject)->MoveEx(lRows);
}
void CSRecordSet::MoveNextNotEof(void){
    ((CXdbRecordset*)pObject)->MoveNextNotEof();
}
void CSRecordSet::MoveNext(void){
    ((CXdbRecordset*)pObject)->MoveNext();
}
void CSRecordSet::MovePrev(void){
    ((CXdbRecordset*)pObject)->MovePrev();
}
void CSRecordSet::MoveLast(void){
    ((CXdbRecordset*)pObject)->MoveLast();
}
void CSRecordSet::MoveFirst(void){
    ((CXdbRecordset*)pObject)->MoveFirst();
}
void CSRecordSet::SetAbsolutePosition(long lRows){
    ((CXdbRecordset*)pObject)->SetAbsolutePosition(lRows);
}
long CSRecordSet::GetAbsolutePosition(void){
    return ((CXdbRecordset*)pObject)->m_AbsolutePosition;
}
long CSRecordSet::GetRecordCount(void){
    return ((CXdbRecordset*)pObject)->GetRecordCount();
}
int CSRecordSet::GetFieldCount(void){
    return ((CXdbRecordset*)pObject)->GetFieldCount();
}
int CSRecordSet::GetRstTableNumber(void){
    return ((CXdbRecordset*)pObject)->GetRstTableNumber();
}
void CSRecordSet::GetFieldName(int nFieldIndex, char *pbuffer){
    ((CXdbRecordset*)pObject)->GetFieldName(nFieldIndex,pbuffer);
}
int CSRecordSet::GetFieldIndex(const char *sFieldName){
    return ((CXdbRecordset*)pObject)->GetFieldIndex(sFieldName);
}
bool CSRecordSet::IsMemoFileTable(void){
    return ((CXdbRecordset*)pObject)->IsMemoFileTable();
}
bool CSRecordSet::IsNumberField(int nFieldIndex){
    return ((CXdbRecordset*)pObject)->IsNumberField(nFieldIndex);
}
bool CSRecordSet::GetFieldValueIntoBuffer(int nFieldIndex,char *pbuffer){
    return ((CXdbRecordset*)pObject)->GetFieldValueIntoBuffer(nFieldIndex,pbuffer);
}
void CSRecordSet::Edit(void){
    ((CXdbRecordset*)pObject)->Edit();
}
bool CSRecordSet::Update(void){
    return ((CXdbRecordset*)pObject)->Update();
}
bool CSRecordSet::SetFieldValue(int nFieldIndex, XdbVar& var){
    return ((CXdbRecordset*)pObject)->SetFieldValue(nFieldIndex,var);
}
bool CSRecordSet::SetFieldValueFromBuffer(int nFieldIndex,const char *pbuffer){
    return ((CXdbRecordset*)pObject)->SetFieldValueFromBuffer(nFieldIndex,pbuffer);
}
bool CSRecordSet::GetFieldValue(int nFieldIndex, XdbVar& var){
    return ((CXdbRecordset*)pObject)->GetFieldValue(nFieldIndex,var);
}
bool CSRecordSet::SeekRecord(XSEK *SEK){
    return ((CXdbRecordset*)pObject)->TableSeek(SEK);
}
bool CSRecordSet::SeekRecord(int nFieldIndex,char *key, int length){
    return ((CXdbRecordset*)pObject)->TableSeek(nFieldIndex,key,length);
}
bool CSRecordSet::SeekRecord(int nFieldIndex,long i){
    return ((CXdbRecordset*)pObject)->TableSeek(nFieldIndex,i);
}
bool CSRecordSet::SeekRecord(int nFieldIndex, double d, int decimals)
{
    return ((CXdbRecordset*)pObject)->TableSeek(nFieldIndex,d,decimals);
}
int CSRecordSet::GetRecordLength(void){
    return ((CXdbRecordset*)pObject)->GetRecordLength();
}
char *CSRecordSet::GetMemoField(int nMemoFieldIndex,char *pbuffer, int BUFFER_SIZE){
    return ((CXdbRecordset*)pObject)->GetMemoField(nMemoFieldIndex,pbuffer,BUFFER_SIZE);
}
bool CSRecordSet::GetBinaryField(unsigned char *buffer,long *buf_size){
    return ((CXdbRecordset*)pObject)->GetBinaryField(buffer,buf_size);
}
LPXSQL CSRecordSet::GetSQL(void){
    return ((CXdbRecordset*)pObject)->GetSQL();
}
void CSRecordSet::GoToLast(void){
    ((CXdbRecordset*)pObject)->GoToLast();
}
long CSRecordSet::GetRecordID(void){
    return ((CXdbRecordset*)pObject)->GetRecordID();
}
int CSRecordSet::GetStandardFieldCount(void){
    return ((CXdbRecordset*)pObject)->GetStandardFieldCount();
}
int CSRecordSet::GetTableType(void){
    return ((CXdbRecordset*)pObject)->GetTableType();
}
int CSRecordSet::GetFieldType(int nFieldIndex){
    return ((CXdbRecordset*)pObject)->GetFieldType(nFieldIndex);
}
int CSRecordSet::GetFieldDGSize(int nFieldIndex){
    return ((CXdbRecordset*)pObject)->GetFieldDGSize(nFieldIndex);
}
int CSRecordSet::GetFieldSize(int nFieldIndex){
    return ((CXdbRecordset*)pObject)->GetFieldSize(nFieldIndex);
}

编辑：由DeadMG请求：

void nimportequoidumomentquecaroule(void) {

    short i = -4;
    unsigned short j=(unsigned short)i;

}