提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

• 一、数组
• • 1.排序
• 二、指针
• • 1.函数指针
  • 2.lamda表达式
• 三、动态分配内存
• • 1.malloc与new区别
  • 2.delete与free区别
• 四、动态分配内存
• • 1.深复制与浅复制

---

一、数组

在c++标准库中对数组进行封装，得到了一个类vetcor，实现了数组存储数据的单一性、连续性、有序性的。
为了实现连续性，会将之前的申请的空间释放继续申请足够大的空间用于存放数据。
vector在作为函数形参时，可以不用传递数组的长度，可以通过调用函数来实现。

1.排序

int vector_sort(vector <int> &p)
{
    size_t i =0;
    size_t j =0 ;
    for(i=0;i<p.size()-1;++i)
    {
        for(j=0;j<p.size()-i-1;++j)
        {
            if(p[j]>p[j+1])
            {
                int temp = p[j];
                p[j] = p[j+1];
                p[j+1] = temp;
            }
        }
    }
    return 0;
}
void show(vector <int> &p)
{
    for(size_t i=0;i<p.size();++i)
    {
        cout<<p[i]<<endl;
    }
    return;
}
int main()
{
    vector <int> a ={1,2,3,4,5,6,7,8,0};

    vector_sort(a);
    show(a);
    cout << "Hello World!" << endl;
    return 0;
}

二、指针

运算：
相减（类型必须一致）表示相差一个基类型 ，可以是正负。
空指针：是一种状态
C++提供的新的关键字：nullptr
gethostbyname();
返回值：可以是一个引用：
（1）静态变量
（2）全局变量

1.函数指针

为了降低程序的耦合度。

bool div2(int num)
{
    return num %2 ==0;
}
int numdiv(int*p,size_t len,bool fun(int num))
{
    size_t i;
    size_t conut =0;
    for(i=0;i<len;++i)
    {
        if(fun(p[i]))
        {
            conut++;
        }
    }
    return conut;
}
int main()
{

  int a[5]={1,2,3,4,5};
  /**函数指针形式/
  cout<<numdiv(a,5,div2)<<endl;
  /*lamda表达式形式*/
  cout<<numdiv(a,5,[](int n)->bool{return n%2==0;})<<endl;
  return 0;
}

2.lamda表达式

lamda表达式：匿名函数，短小函数就地编写。
capture{body}
在函数体值传递不能修改参数，可以做引用修改

int compare(const void *p1, const void *p2)
{

    int *q1=reinterpret_cast<int*> (const_cast<void*> (p1));
    int *q2=reinterpret_cast<int*> (const_cast<void*> (p2));
    return *q2-*q1;
}

int main()
{

    int a[5]={1,2,3,4,5};
    qsort(a,5,sizeof(a[0]),[](const void *p1, const void *p2){return *((int*)p1)-*((int*)p2);});
    for(auto &x:a)
    {
        cout<<x<<endl;
    }
    return 0;
}

三、动态分配内存

1.malloc与new区别

void *realloc(void *ptr, size_t size);
原来开辟的内存空间大小不够，可以调用realloc开辟想要打的空间。
（1）malloc没有构造函，new会触发构造函数
（2）malloc是一个函数，new是一个关键字
（3）new智能申请什么类型，返回什么类型的指针，malloc则是返回void再由使用者进行类型转换

2.delete与free区别

代码如下（示例）：

四、动态分配内存

1.深复制与浅复制

浅复制：只是将类数据成员拷贝过来
深复制：将浅复制所指向的空间（堆空间）拷过来。
实现mystring；

class Mystring
{
public:
    Mystring(const char *pstr);

    Mystring(const Mystring &other);

    ~Mystring();
    void show()const;
    void append(const char *pstr);
    void append(const Mystring &other);
    void assign(const Mystring &other);
    size_t size()const;

private:
    char*m_s;

};
Mystring::Mystring(const char *pstr):m_s(new char[strlen(pstr)+1])
{
    strcpy(m_s,pstr);
}
Mystring::Mystring(const Mystring &other):m_s(new char[strlen(other.m_s)+1])
{
    strcpy(m_s,other.m_s);
}
Mystring::~Mystring()
{
    delete []m_s;
}
void Mystring::show()const
{
    cout<<m_s<<endl;
   return;
}
void Mystring::append(const char *pstr)
{
    char *p = new char[strlen(m_s)+strlen(pstr)+1];
    strcpy(p,m_s);
    strcat(p,pstr);
    delete m_s;
    m_s = p;

    return;
}
void Mystring::append(const Mystring &other)
{
    char *p = new char[strlen(m_s)+strlen(other.m_s)+1];
    strcpy(p,m_s);
    strcat(p,other.m_s);
    delete m_s;
    m_s = p;
    return;
}
size_t Mystring::size()const
{
    return strlen(m_s);
}
void  Mystring::assign(const Mystring &other)
{
    if(!(&other == this))
    {
        char * p= new char[strlen(other.m_s)+1];
        strcpy(p,other.m_s);
        delete []m_s;
        m_s = p;
    }

    return;
}
int main()
{
    Mystring s1("1111");
    Mystring s2("222");
    s1.show();
    s2.show();
    s2.assign(s1);
     s2.show();

    return 0;
}