首页 > 代码库 > C++C++ 指针（二）--c++ 指针（二）--c++

C++C++ 指针（二）--c++ 指针（二）--c++

2024-08-16 16:24:45   222人阅读

一、内存管理：new和delete

1、new操作符：从操作系统获得内存块，并返回该内存块的首地址。

      delete操作符：将new申请的内存返还给操作系统。

开始一个简单的例子：

#include <iostream>
#include<cstring>
using namespace std;
int main()
{
    char* str="it is a good job!";
    int len=strlen(str);
    char* ptr=new char[len+1];
    strcpy(ptr,str);
    //ptr=str;  //错误，这样是ptr和str都指向字符串。这里ptr和str应该指向不同的地址。
    cout<<"ptr="<<ptr<<endl;
    delete[] ptr;
    return 0;
}
1） new格式：
char* ptr = new char [len+1]
 

指针

=

关键字

变量的数据类型

char类型变量的数目（方括号）
         new和malloc：new方法可以返回适当的数据类型的指针；而malloc返回的指针是void类型的指针，必须强制转化才能转化成适当的数据类型指针。
C中的realloc函数可以改变已分配内存空间的大小。C++中没有这样的函数，只能通过new重新申请一个更大或者更小的空间。
2） delete格式：delete【】 要删除的指针
如果new创建的是一个简单的对象，则在删除的时候可不加方括号，如果是数组就必须加括号。
 

2.使用new的类

#include<iostream>
using namespace std;
class String
{
public:
    String(char* s)
    {
        int len=strlen(s);
        str=new char[len+1];
        strcpy(str,s);
    }
    ~String()
    {
        cout<<"where?"<<endl;
        delete[] str;
    }
    void display()
    {
        cout<<str<<endl;
    }
private:
    char* str;
};
int main()
{
    String str="hello! word!";
    str.display();
    return 0;  
}

1）在构造函数中使用new获得内存空间。

2）既然使用new来分配内存空间，因而析构函数也变得很重要。（因为在创建对象的时分配了内存空间，则当这些对象不再需要时就很有必要释放这些空间）。析构函数在对象销毁时自动调用的例程，所以放入delete恰好。

问题：如果一个类的两个对象执行了s1=s2这样的操作（即出现两个对象的指针指向同一个内存地址），而此时一个对象被删除（如含有其中一个对象的调用函数结束后返回时），这样申请的内存地址被收回，这样就导致另一个对象的是一个无效的指针了。

    这个错误一定要重视，因为很容易疏忽。怎样才能写一个更聪明的析构函数呢？？   后面揭晓…

二、对象与指针

1、对象指针

有时在程序的编写时并不知道需要创建多少个对象。当出现这中情况时，就可以在程序运行中使用new来穿件对象。这里，new返回的是一个指向未命名对象的指针。

例子：

#include<iostream>
using namespace std;
class Distance
{
public:
    void getdist();
    void showdist();
private:
    int feet;
    float inches;
};
void Distance::getdist()
{
    cout<<"Enter the feet:"; cin>>feet;
    cout<<"Enter the inches:";cin>>inches;
}
void Distance::showdist()
{
    cout<<"The feet:"<<feet<<endl;
    cout<<"The inches:"<<inches<<endl;
}
int main()
{
    Distance dd;
    dd.getdist();
    dd.showdist();
    Distance* ptr=new Distance; // pointer to Distance,points to new Distance object
    ptr->getdist();  //这里如果是点运算符就会出错
    ptr->showdist(); //因为点运算符要求它的左运算符是一个变量，而ptr为一个指针。
    return 0;
}

 

上面标注的地方除了用成员访问运算符（->）表示之外，我们还可以这样(*ptr).getdist(); //ok，but inelegant （圆括号是必须的，因为点运算符的优先级比间接引用运算符要高）.

2、对象指针数组

Distance* distptr[100];
distptr[j]=new Distance;
//*(distptr+j)=new Distance;
distptr->getdist();
distptr->showdist();

注意：数组表示法distptr[j]等价于指正表示法*(distptr+j)，由于是指针数组，上面两种表示的方法的元素还是指针（指向对象的指针）

          distptr->getdist(); 表示执行了由数组distptr的第j个元素 所指向的Distance对象的成员函数。

三、链表

链表提供了一种不使用数组但更为灵活的存储系统，每个数据项都是按照需要通过new来获取的，且数据之间是通过指针链接起来的。

单个数据项之间并不需要和数组元素一样在内存中相邻分配，相反他们可以分散到任何地方。

例子：

#include <iostream>
using namespace std;
struct link
{
    int data;     //表示对象的单个数据项
    link* next;   //指向下一个链接项
};
class linklist
{
public:
    linklist():first(NULL) {}
    void addlist(int d);   //增加链接项
    void display();        //显示链接内容
private:
    link* first;
};
void linklist::addlist(int d)  //增加链接项
{
    link* newptr=new link; //创建一个新的link结构类型
    newptr->data=http://www.mamicode.com/d; //将参数的值传递给结构变量data 
    newptr->next=first;    //指针next指向first指向的任何地址（在这里是链表头）
    first=newptr;          //将指针first指向这个新的链接项
}
void linklist::display()
{
    link* nowptr=first;
    while (nowptr!=NULL)
    {
        cout<<nowptr->data<<endl;
        nowptr=nowptr->next;  //指针移动到下一个链表的地址
    }
}
int main()
{
    linklist ll;
    ll.addlist(22);
    ll.addlist(33);
    ll.addlist(44);
    ll.display();
    return 0;
}

 

技术分享

注意：在使用link结构的时候含有一个指向同类型结构的指针。同样的在类中也可以这么使用：

class sampleclass
{
    sampleclass* ptr;   //this is fine！
    sampleclass obj;    //can‘t do this！！
};

 

但是这里要特别注意：虽然类中可以包含一个指向同类型对象的一个指针，但不能包含一个同类的对象。

四、指向指针的指针

看个例子：

#include<iostream>
#include <string>
using namespace std;
class person
{
public:
    void SetName()
    {
        cout<<"Enter name:"; cin>>name;
    }
    void PrintfName()
    {
        cout<<name;
    }
    string GetName()
    {
        return name;
    }
private:
    string name;
};
int main()
{
    void bsort(person**,int);     //排序
    person* perptr[100];
    int n=0;
    char ch;
    do
    {
        *(perptr+n)=new person;
        (*(perptr+n))->SetName();
        n++;
        cout<<"Enter another?";
        cin>>ch;
    } while (ch==‘y‘);
    cout<<"姓名排序前：";
    for (int j=0;j<n;j++)
    {
        perptr[j]->PrintfName();
        cout<<" ";
    }
    bsort(perptr,n);
    cout<<"\n姓名排序后：";
    for (int j=0;j<n;j++)
    {
        perptr[j]->PrintfName();
        cout<<" ";
    }
    cout<<endl;
    return 0;
}
void bsort(person** ptr,int n)  //排序
{
    void order(person**,person**);
    int j,k;
    for(j=0;j<n-1;j++)
        for(k=j+1;k<n;k++)
            order(ptr+j,ptr+k);
}
void order(person** ptr1,person** ptr2)  //比较
{
    if((*ptr1)->GetName()>(*ptr2)->GetName()))
    {
        person* tem;
        tem=*ptr1;
        *ptr1=*ptr2;
        *ptr2=tem;
    }
}

 

1）注意到数据类型person**，表示这些参数被用来传递perptr指针数组的地址。本身perptr数组中存的就是指针，因此指针数组的地址是一个指向指针的指针。

2）因为数组perptr包含的是指针，因而：perptr[j]->PrintfName();  表示执行perptr数组的j号元素所指向的对象的PrintfName()成员函数。

3）(*ptr1)->GetName()；

其中ptr1是一个指向指针的指针，因此(*ptr1)表示指针数组的元素。总体意思就是执行perptr数组的元素(*ptr1)所指向的对象的PrintfName()成员函数。

C++C++ 指针（二）--c++ 指针（二）--c++


联系
我们