Warum werden Zeiger beim Codieren mit C ++ nicht empfohlen?

Ich habe irgendwo gelesen, dass bei der Verwendung von C ++ empfohlen wird, keine Zeiger zu verwenden. Warum sind Zeiger eine so schlechte Idee, wenn Sie C ++ verwenden. Was ist die bessere Alternative und Vorgehensweise in C ++ für C-Programmierer, die an die Verwendung von Zeigern gewöhnt sind?

Ich denke, sie bedeuten, dass Sie intelligente Zeiger anstelle von regulären Zeigern verwenden sollten.

In der Informatik ist ein intelligenter Zeiger ein abstrakter Datentyp, der einen Zeiger simuliert und gleichzeitig zusätzliche Funktionen wie die automatische Speicherbereinigung oder die Grenzwertprüfung bereitstellt. Diese zusätzlichen Funktionen sollen Fehler reduzieren, die durch den Missbrauch von Zeigern verursacht werden, während die Effizienz erhalten bleibt. Intelligente Zeiger verfolgen normalerweise die Objekte, auf die sie zum Zwecke der Speicherverwaltung zeigen.

Der Missbrauch von Zeigern ist eine Hauptursache für Fehler: Die ständige Zuordnung, Freigabe und Referenzierung, die von einem mit Zeigern geschriebenen Programm durchgeführt werden muss, birgt das Risiko, dass Speicherlecks auftreten. Intelligente Zeiger versuchen, Speicherverluste zu verhindern, indem sie die automatische Freigabe der Ressource veranlassen: Wenn der Zeiger (oder der letzte in einer Reihe von Zeigern) auf ein Objekt zerstört wird, z.

In C ++ liegt der Schwerpunkt auf der Garbage Collection und der Vermeidung von Speicherverlusten (um nur zwei zu nennen). Zeiger sind ein grundlegender Bestandteil der Sprache, daher ist es so gut wie unmöglich, sie nicht zu verwenden, es sei denn, es handelt sich um die trivialsten Programme.

Da ich derjenige bin, der die Polemik "benutze keine f * kking-Zeiger" veröffentlicht hat, denke ich, dass ich hier einen Kommentar abgeben sollte.

Als Polemik ist es offensichtlich ein extremer Gesichtspunkt. Es gibt definitiv legitime Verwendungen von (rohen) Zeigern. Aber ich (und viele professionelle C ++ - Programmierer) behaupten, dass diese Fälle äußerst selten sind. Aber was wir wirklich meinen, ist das Folgende:

Zuerst:

Raw Pointer dürfen auf keinen Fall eigenen Speicher besitzen.

Hier bedeutet "eigenes Gedächtnis" im Wesentlichen, dass irgendwann deleteauf diesen Zeiger zugegriffen wird (aber es ist allgemeiner als das). Diese Aussage kann mit Sicherheit als absolut angesehen werden. Die einzige Ausnahme ist die Implementierung eines eigenen Smart Pointers (oder einer anderen Speicherverwaltungsstrategie). Und selbst dort sollten Sie normalerweise noch einen Smart Pointer auf niedriger Stufe verwenden.

Die Begründung hierfür ist ganz einfach: Rohe Zeiger, die über Speicher verfügen, führen zu einer Fehlerquelle. Und diese Fehler sind in bestehender Software sehr häufig: Speicherverluste und doppeltes Löschen - beides eine direkte Folge von unklarem Ressourcenbesitz (aber in entgegengesetzter Richtung).

Dieses Problem kann praktisch kostenlos vollständig beseitigt werden, indem einfach intelligente Zeiger anstelle von unformatierten Zeigern verwendet werden (Vorsicht: Dies erfordert natürlich noch Nachdenken; gemeinsame Zeiger können zu Zyklen und damit wiederum zu Speicherverlusten führen - dies ist jedoch einfach vermeidbar).

Zweite:

Die meisten Verwendungen von Zeigern in C ++ sind nicht erforderlich.

Im Gegensatz zu anderen Sprachen unterstützt C ++ die Wertesemantik sehr stark und benötigt einfach keine Indirektion von Zeigern. Dies wurde nicht sofort erkannt - in der Vergangenheit wurde C ++ erfunden, um eine einfache Objektorientierung in C zu ermöglichen, und es wurde stark darauf geachtet, Objektgraphen zu konstruieren, die durch Zeiger verbunden waren. In modernem C ++ ist dieses Paradigma jedoch selten die beste Wahl, und moderne C ++ - Redewendungen benötigen häufig überhaupt keine Zeiger . Sie arbeiten eher mit Werten als mit Zeigern.

Leider hat sich diese Nachricht in weiten Teilen der C ++ - Benutzergemeinschaft noch nicht durchgesetzt. Infolgedessen ist der größte Teil des geschriebenen C ++ - Codes immer noch mit überflüssigen Zeigern übersät, die den Code komplex, langsam und fehlerhaft / unzuverlässig machen.

Für jemanden, der modernen C ++ kennt, dann ist es klar , dass man sehr selten brauchen keine Zeiger (entweder intelligent oder roh, außer wenn sie als Iteratoren verwenden). Der resultierende Code ist kürzer, weniger komplex, besser lesbar, oft effizienter und zuverlässiger.

Ganz einfach, weil Ihnen Abstraktionen zur Verfügung stehen, die die eher temperamentvollen Aspekte der Verwendung von Zeigern verbergen, z. B. den Zugriff auf den unformatierten Speicher und das Aufräumen nach Ihren Zuweisungen. Mit intelligenten Zeigern, Containerklassen und Entwurfsmustern wie RAII wird der Bedarf für die Verwendung von rohen Zeigern verringert. Das heißt, wie bei jeder Abstraktion sollten Sie verstehen, wie sie tatsächlich funktionieren, bevor Sie darüber hinausgehen.

Relativ einfach ausgedrückt lautet die C-Mentalität "Haben Sie ein Problem? Verwenden Sie einen Zeiger". Sie können dies in C-Strings, Funktionszeigern, Zeigern als Iteratoren, Zeigern auf Zeiger und ungültigen Zeigern sehen - selbst in den frühen Tagen von C ++ mit Elementzeigern.

In C ++ können Sie jedoch Werte für viele oder alle dieser Aufgaben verwenden. Benötigen Sie eine Funktionsabstraktion? std::function. Es ist ein Wert, der eine Funktion ist. std::string? Es ist ein Wert, das ist eine Zeichenfolge. Sie können ähnliche Ansätze in C ++ beobachten. Dies erleichtert die Analyse des Codes sowohl für den Menschen als auch für den Compiler erheblich.

Einer der Gründe ist die zu weite Anwendung von Zeigern. Sie können zum Durchlaufen von Containern verwendet werden, um zu vermeiden, dass große Objekte beim Übergeben an eine Funktion kopiert werden, nicht triviale Lebensdauerverwaltung, Zugriff auf zufällige Speicherbereiche usw. Sobald Sie sie für einen Zweck verwendet haben, stehen andere Funktionen zur Verfügung sofort selbständig auf Vorsatz.

Die Auswahl eines Tools für den genauen Zweck macht Code einfacher und bewusster sichtbar - Iteratoren für Iterationen, intelligente Zeiger für die Lebensdauerverwaltung usw.

Neben den bereits aufgeführten Gründen gibt es eine offensichtliche: bessere Optimierungen. Die Aliasing-Analyse ist in Gegenwart einer Zeigerarithmetik viel zu kompliziert, wohingegen Referenzen auf einen Optimierer hinweisen, sodass eine viel tiefere Aliasing-Analyse möglich ist, wenn nur Referenzen verwendet werden.

Neben dem von @jmquigley angegebenen Risiko von Speicherlecks kann die Zeiger- und Zeigerarithmetik als problematisch angesehen werden, da Zeiger überall im Speicher hinweisen können und "schwer zu findende Fehler" und "Sicherheitslücken" verursachen.

Aus diesem Grund wurden sie in C # und Java fast aufgegeben.

C ++ unterstützt die meisten Funktionen von C sowie Objekte und Klassen. C hatte schon Zeiger und andere Sachen.

Zeiger sind eine sehr nützliche Technik, die mit der Objektorientierung kombiniert werden kann, und C ++ unterstützt sie. Diese Technik ist jedoch schwer zu lehren und zu verstehen, und es ist sehr leicht, unerwünschte Fehler zu verursachen.

Viele neue Programmiersprachen geben vor, keine Zeiger für Objekte zu verwenden, wie Java, .NET, Delphi, Vala, PHP, Scala. Es werden jedoch weiterhin Zeiger "hinter den Kulissen" verwendet. Diese "versteckten Zeigertechniken" werden "Referenzen" genannt.

Wie auch immer, ich betrachte Zeiger als Programmiermuster, als einen gültigen Weg, um bestimmte Probleme zu lösen, so wie es die objektorientierte Programmierung tut.

Andere Entwickler sind möglicherweise anderer Meinung. Ich schlage jedoch vor, dass Studenten und Programmierer lernen, wie man:

(1) Verwenden Sie Zeiger ohne Objekte

(2) Objekte ohne Zeiger

(3) explizite Zeiger auf Objekte

(4) "versteckte" Zeiger auf Objekte (AKA- Referenz ) ;-)

In dieser Reihenfolge.

Auch wenn es schwer zu lehren und schwer zu lernen ist. Object Pascal (Delphi, FreePascal, andere) und C++(nicht Java oder C #) können für diese Ziele verwendet werden.

Und später können unerfahrene Programmierer Programmiersprachen wie Java, C #, objektorientiertes PHP und andere "versteckte Zeiger auf Objekte" verwenden.

Apropos VC6: Wenn Sie einen Zeiger einer Klasse (die Sie instanziieren) in eine Variable (z. B. DWORD) umwandeln, können Sie, auch wenn dieser Zeiger lokal ist, über alle Funktionen, die denselben Heap verwenden, auf die Klasse zugreifen. Die instanziierte Klasse ist als lokal definiert, ist es jedoch nicht. Soweit ich weiß, ist jede Adresse einer Heap-Variablen, -Struktur oder -Klasse während des gesamten Lebens der Hosting-Klasse eindeutig.

Beispiel:

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;
}

EDIT Das ist ein sehr kleiner Teil des Originalcodes. Die CSRecodset-Klasse ist nur eine Casting-Klasse von CXdbRecordset, in der der gesamte echte Code enthalten ist. Auf diese Weise kann der Benutzer das, was ich geschrieben habe, nutzen, ohne meine Rechte zu verlieren. Ich behaupte nicht, dass meine Datenbank-Engine professionell ist, aber es funktioniert wirklich.

//-------------------------------------
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);
}

EDIT: beantragt von DeadMG:

void nimportequoidumomentquecaroule(void) {

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

}