C++ 数组 -- 指针 -- 字符串 第六章

已于 2024-08-11 17:37:51 修改
阅读量591 收藏 17
点赞数 7
文章标签： c++ 开发语言
于 2024-08-09 13:30:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kxy102852/article/details/140997052
版权

 数组



指针

指针处理数组元素：

🙋‍♂️练习：实现数组的打印

（1）

（2）

#include <iostream>
#include <cstdlib>
using namespace std;

bool fn(int)
{
    return true;
}

void printArray(int *a,int len, bool(*pfn)(int))
{
    for(int i = 0;i <len; ++i)
    {
        if(pfn(a[i]))
        {
            cout << a[i] << endl;
        }
    }
}

int intcmp(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 *q1 - *q2;
}

int main()
{
    int a[] = {1,2,0,4,5,6,-1,8,-3,0};

    int len = sizeof(a)/sizeof(*a);
    printArray(a,len,fn);
    return 0;
}

🙋‍♂️练习：实现快速排序


另一种方式 lamda  

lamda:短小函数就地编写

 

（4）二维数组的打印

指针型函数

定义：一个指针可以指向函数

数据类型 * 函数名（参数名）

{

      函数体

}

作用：降低程序耦合性

降低耦合性： 

int add(int a,int b)
{
    return a+b;
}
bool div3(int n)
{
    return n%3==0;
}
bool div2(int n)
{
    return n%2==0;
}
bool fn(int)
{
    return true;
}
void printArray(int *a,int len,bool (*pfn)(int))
{
    for(int i = 0;i<len;i++)
    {
        if(pfn(a[i]))
        {
            cout << a[i]<<endl;
        }
    }

}
int main()
{
    int (*p)(int ,int)=nullptr;
    int a[]={1,10,2,7,3,5,6,8,9};
    int len=sizeof(a)/sizeof(*a);
     printArray(a,len,div3);
     //printArray(a,len,add);
    //printArray(a,len,div2);
     return 0;
}

🙋‍♂️练习：实现斐波那契数列

数列的前几项是：0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...

int fib(int n)//feibonaqieshulie
{
    if(1 == n || 2 == n)
    {
        return 1;
    }
    else
    {
        return fib(n-1) + fib(n-2);
    }
}
void printArray(int *a,int len)
{
    for(int i = 0;i< len; ++i)
    {
        cout << *(a+i) << endl;
    }
}
int main(void)
{
    int n = 10;
    int *p = new int[n];
    for(int j = 0; j< n ;++j)
    {
        p[j] = fib(j+1);
    }
    printArray(p,n);
}

🙋‍♂️练习：实现容量的扩展 fib

#include <cstring>
#include <iostream>
#include <cstdlib>
using namespace std;

int fib(int n)//fib
{
    if(1 == n || 2 == n)
    {
        return 1;
    }
    else
    {
        return fib(n-1) + fib(n-2);
    }
}
void printArray(int *a,int len)
{
    for(int i = 0;i< len; ++i)
    {
        cout << *(a+i) << endl;
    }
}
int main(void)
{
    int n = 10;
    int *p = new int[n];
    for(int i = 0; i < n; ++i)
    {
        p[i] = fib(i+1);
    }
    printArray(p,n);

    int m= 20;
    int *q = new int[m];
    memcpy(q,p,n*sizeof(int));
    delete[]p;
    p = q;
    for(int i = 0;i<m;++i)
    {
        p[i] = fib(i+1);
    }
    printArray(p,m);
    delete []p;
    p = q = nullptr;
    delete p;
    return 0;
}

动态内存分配

关键词 new delete

MyClass* myObject = new MyClass(); // 动态分配内存并调用默认构造函数，没有给出参数类表

delete myObject; //会自动调用析构函数

//  释放内存，否则会导致动态内存的内存无法收回导致程序占据内存越来越大，则内存泄漏

// 这时delete仅仅释放了myObject指向的空间，并调用了析构函数，之后myObject就会变成空指针，即它指向的内存已经被释放，但指针的值没有改变。因此，一个常见的做法是将指针设置为nullptr，以避免野指针（dangling pointer）的问题：

myObject = nullptr;


====  int * p = new int () ; // 初始化
====  int * p = new int [ ] ; 

int * point ;
point = new int (2) ;

delete point ;

// ( )则是赋值的意思，动态分配了用于存放int型数据的内存空间，并将2存入空间，然后将首地址赋给指针point

int *point;

point = new int [ 2 ];

delete[ ] point ;

//如果只是delete point 可能会造成内存泄漏

// [ ] 则表示分配了一个整型数组，其中包含了两个元素

简述malloc free 与new delete 差异   

1. 所属语言及类型

  • malloc和free：它们是C语言标准库中的函数。
  • new和delete：它们是C++中的操作符，不是函数。

2. 内存管理单位

  • malloc和free：以字节为单位进行内存管理，需要手动指定需要分配或释放的字节数。
  • new和delete：以对象为单位进行内存管理，无需手动计算需要分配或释放的字节数，编译器会自动计算。

3. 返回值及类型转换

  • malloc：返回void*类型的指针，需要显式地进行类型转换。
  • new：返回分配对象的指针，不需要显式地进行类型转换。

4. 构造函数与析构函数的调用

  • malloc和free：不会调用构造函数和析构函数。
  • new和delete：会自动调用构造函数和析构函数。

5. 初始化

  • malloc：分配的内存不会自动初始化，其内容是未定义的。
  • new：分配内存的同时可以调用构造函数进行初始化。

6. 错误处理

  • malloc：失败时返回NULL。
  • new：失败时会抛出std::bad_alloc异常。

7. 数组处理

  • malloc和free：对于数组，需要手动计算总字节数并分配，释放时也是通过free。
  • new和delete：对于数组，使用new[]分配，delete[]释放。

8. 类型安全

  • malloc和free：由于返回的是void*类型，存在类型不匹配的风险。
  • new和delete：确保类型安全，因为它们返回的是具体类型的指针。

9. 性能和效率

  • new和delete：作为C++的内置操作符，它们在执行时可能更高效，因为它们与C++的运行时环境紧密集成。
  • malloc和free：虽然它们在C中广泛使用，但在C++中可能不如new和delete高效，特别是在处理对象时。

10. 使用建议

  • 在C++中，推荐使用new和delete进行内存管理，因为它们提供了更好的类型安全性和自动的构造函数/析构函数调用。

如果在C++中需要与C代码交互或处理非对象类型的内存分配，可以考虑使用malloc和free，但应谨慎处理类型转换和内存初始化问题。


 字符串 string类

🙋‍♂️练习：实现append,assign 

string类的成员函数有很多，每个函数都有多种重载形式

  • string append (const char *s) // 将字符串s添加在本串尾



    append追加的重载函数


     
  • string assign ( const char * s)  // 赋值，将s所指向的字符串赋值给本对象



    assign重载


     
  • unsigned int length( )const ; // 返回字符串的长度（字符个数）


     

完整代码： （1）

#include <iostream>
#include <cstring>
using namespace std;
//实现hello!world打印
class String
{
public:
    String(const char *p)
    {
        m_p = new　char[strlen(p) + 1];
        strcpy(m_p,p);
    }
    void show()const //修饰this
    {
        cout<<m_p<<endl;
    }
    // 追加
    void append(const char *p)//存在两个参数还有this->m_p
    {
        char *q = new char[strlen(m_p) + strlen(p) + 1];
        strcpy(q,m_p);
        strcat(q,p);
        delete []m_p;
        m_p = q;
    }
 #if 0
   // 追加重载
    void append(const　String &other)
    {
        //this //other
        char *p = new char[strlen(this->m_p) + strlen(other.m_p) + 1];
        strcpy(p,this->m_p);
        strcat(p,other.m_p);
        delete [] this->m_p;
        this->m_p = p;
    }
#endif
    size_t length()const
    {
        return strlen(m_p);
    }
private:
    char *m_p;
};
int main()
{
    String s("Hello！");
    s.append("world");
    s.show();;
   // cout << "Hello World!" << endl;
    return 0;
}

#if 0
int main()
{
    String s("Hello！");
    String s1("world");
    s.append(s1);
    s.show();;
    return 0;
}
#endif

（2） 

#include <iostream>
#include <cstring>
using namespace std;

//实现赋值将hello->china
class String
{
public:
    String(const char *p)
    {
        m_p = new　char[strlen(p) + 1];
        strcpy(m_p,p);
    }
    void show()const //修饰this
    {
        cout<<m_p<<endl;
    }
    void assign(const char *p)
    {
        char *q = new char[strlen(p) + 1];
        strcpy(q,p); //将china放到新空间
        delete []m_p;
        m_p = q;
    }
// 重载
#if 0
     void assign(const String &other)
    {
        if(this != &other)
        {
          char *q = new char[strlen(other.m_p) +1 ];
          strcpy(q,other.m_p);
          delete []this->m_p;
          this->m_p = q;
        }
    }
#endif
    size_t length()const
    {
        return strlen(m_p);
    }
private:
    char *m_p;
};
int main()
{
    String s("Hello！");
    s.assign("China");//赋值
    s.show();;
    return 0;
}
#if 0
int main()
{
    String s("Hello！");
    String s1("China");
    s.assign(s1);//赋值
    s.show();;
    return 0;
}
#endif

 深复制与浅复制构造

  • 浅复制构造
    定义：浅复制构造仅复制对象成员的值，包括指针成员的值，但不复制指针所指向的内存区域。这意味着，原对象和新对象中的指针成员将指向同一块内存区域。

     
  • 深复制构造
    定义：深复制构造不仅复制对象成员的值，还复制指针成员所指向的内存区域的内容到新的内存区域，并更新新对象的指针成员以指向这块新的内存区域

     
  • 浅复制构造新对象会和原对象共享同一块内存，所以当其中一个对象被销毁时候调用的析构函数会将动态分配的内存释放，这是另一个对象的指针就会变成悬空指针，这时就会导致内存访问失败，但是深复制构造函数不会存在这个问题，因为新的ptr会指向一块新的区域，该区域原来的ptr指向的副本，所以它们各自独立。
    （先销毁ptr1时调用析构，析构函数会使开辟的空间销毁，随后当销毁ptrz时候析构函数会将相同的空间销毁两次，虽然可以实现但是会报错，这时候就要将浅复制构造变为深复制构造，再开辟一个空间）

List

list 的构造

  • 实现头插
  • 获得结点个数
  • 实现头删

  • 实现尾插


     
  • 实现尾删

  • 清除

完整代码：

#include <iostream>
#include <cstring>
using namespace std;

struct Node
{
    Node(int value =0,Node *p=nullptr):data(value),next(p){}
    int data;
    Node *next;
};
class List
{
public:
    List():pHead(nullptr){}
    List(const List &other ):pHead(nullptr)
    {
        Node *p = other.pHead;
        while(p != nullptr)
        {
            this->push_back((p->data));
            p = p->next;
        }
    }


    void push_front(int n)
    {
        Node *pNew =new Node(n);
        pNew->next=pHead;
        pHead= pNew;
    }
    size_t size() const
    {
        size_t cout=0;
        Node *p=pHead;
        while(p)//p!=nullptr
        {
            cout ++;
            p=p->next;
    }
        return cout;
    }
    void push_back(int n)
    {
        if(isEmpty())
        {
            push_front(n);
        }
        else
        {
            Node *pNew = new Node(n);
            Node *p=pHead;
            while(p->next)
            {
                p=p->next;
            }
            p->next=pNew;
        }
    }
    void pop_front(void)
    {
        if(!isEmpty())
        {
            Node *p=pHead;
            pHead=p->next;
            delete p;
        }
    }
    void pop_back(void)
    {
        if(size() >= 2)
        {
            Node *p =pHead;
            while(p->next->next != nullptr)
            {
                p = p->next;
            }
            delete p->next;
            p->next = nullptr;
        }
        else
        {
            pop_front();
        }
    }
    void clean(void)
    {
        while(!isEmpty())
        {
            pop_front();
        }
    }
    bool isEmpty() const
    {
        return pHead == nullptr;
    }
    void show()
    {
        Node *p=pHead;
        while(p)
        {
            cout<<p->data<<",";
            p=p->next;
        }
        cout <<"\b\n";
    }

private:
    Node *pHead;

};
int main()
{
    List l;
    cout<<"size = "<<l.size()<<endl;
    cout<<"isEnpty = "<<l.isEmpty()<<endl;
    //头插
    l.push_front(1);
    l.push_front(2);
    l.push_front(3);
    
    //尾插
    l.push_back(4);
    
    //头删
    l.pop_front();
    
    //尾删
    l.pop_back();
    
    //清除
    l.clean();
    
    l.show();
    cout<<"size = "<<l.size()<<endl;
    cout<<"isEnpty = "<<l.isEmpty()<<endl;
    return 0;
}

 

y.ki
关注
C++-数组-指针-引用模块
Asincereman的专栏
01-05 882
指针：C语言中某种数据类型的数据存储的内存地址，例如：指向各种整型的指针或者指向某个结构体的指针。数组：若干个相同C语言数据类型的元素在连续内存中储存的一种形态。数组在编译时就已经被确定下来，而指针直到运行时才能被真正的确定到底指向何方。所以数组的这些身份(内存)一旦确定下来就不能轻易的改变了，它们(内存)会伴随数组一生；而指针则有很多的选择，在其一生他可以选择不同的生活方式，比如一个字符指针可以指向单个字符同时也可代表多个字符等。
第四章节-28--数组--Vector -字符串
qq_43642885的博客
08-08 707
在C++中，数组的名称实际上是指向数组第一个元素的指针，但是数组本身并不是一个可赋值的对象（如类对象）。数组的长度和内存布局在定义时就已经确定，因此不能简单地通过。这个空字符非常重要，因为它告诉程序哪里是字符串的结束，而不仅仅是数组中的最后一个字符。操作符在C++中处理的是赋值而不是拷贝，这种直接赋值在编译时是不合法的。在C++中，数组的初始化行为在函数内部和全局域的确是不同的。编译器会将其解释为一个字符数组，并在数组的末尾自动添加一个空字符。返回一个指针，指向分配的这块内存的第一个字节（即第一个。
c++入门----适用于初学者（7）----数组、字符串和指针
2201_75867204的博客
08-27 374
数组、字符串和指针
C/C++基础 -- 指针与数组、字符串(包含二维数组)
不世峰兄 的博客
09-07 2628
C++基础 -- 指针与数组1、一维数组和指针1.1、一维数组的地址1.2、指向一维数组的指针变量1.3、通过指针访问一维数组元素 1、一维数组和指针 1.1、一维数组的地址   数组由若干元素组成，每个元素都有相应的地址，通过取址运算符（&）可以得到每个元素的地址。   C++规定，数组名既代表数组本身，又代表整个数组的地址，还是数组首元素的地址。即a与a的第0个元素的地址&a...
计算机程序设计c++ 8-3：指向一维数组指针(行指针)及字符串指针
uncle_ll的博客
11-09 1853
指向具有M个元素的一维数组指针 定义格式如下： 类型 (*指针变量)[M]; //M为一整型常量 通常利用该指针变量，指向二维数组的行地址，其中M表示二维数组的列数。 例如：利用行指针变量，按行输出二维数组各元素值 方法1: int a[3][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}}; int (*p)[4]; for(p=a; p<a+3; p++) // p++ 行++ { //输出p所指行的各列元素值 for(int j=0; j<
C++指针解读（6）-- 指针和字符串
10-15 764
字符串，及指向字符串的指针等相关概念。
C++语言程序设计笔记 - 第6章 - 数组、指针与字符串
oddmarmot的博客
12-05 1421
文章目录第6章 数组、指针与字符串6.1 数组6.1.1 数组的声明与使用6.1.2 数组的存储与初始化6.1.3 数组作为函数参数6.1.4 对象数组6.2 指针6.2.1 内存空间的访问方式6.2.2 指针变量的声明6.2.3 与地址相关的运算“`*`”和“`&`”6.2.4 指针的赋值6.2.5 指针运算6.2.6 用指针处理数组元素6.2.7 指针数组6.2.8 用数组作为函数参数6.2.9 指针型函数6.2.10 指向函数的指针（函数指针）6.2.11 对象指针6.2.11.1 对象指针的
c++第6章·数组、指针与字符串
qq_61786525的博客
04-28 396
数组 数组的存储 数组元素在内存中是顺序的、连续存储的 数组的初始化 第一维的下标个数可以不用显式说明（因为可以根据后面的维度算出来） 数组也可以被声明常量 const float fa[5]={1.0,2.0,3.0} 表明fa数组中每个元素都被当作常量对待，也就是说它们的值在初始化后皆不可以改变 数组作为函数参数 void a(int a[4]){ cout<<a[0]; } int main(){ int b[3]; int c[4]; in
C++入门学习3-指针与字符数组，函数，指针数组
qq_52508038的博客
11-05 1261
C语言/C++中 指针的基础知识
C/C++ 数组 指针 字符串
elderingezez的博客
10-16 130
字符串常量的值复制到字符串数组中，字符串数组建立新的内存空间，与字符串常量的地址不同，字符串数组因为其数组的特性，a[0]作为该数组的地址，导致数组的位置不能随意改变，如若改变会造成数组a[1]、a[2]等数据混乱。总之，当使用"%s"格式控制符输出指针和数组时，需要确保指针指向的字符串以null结尾，字符数组具有正确的字符串终止符，并确保数组长度足够容纳字符串，以避免潜在的错误和未定义行为。1. 指针输出：在这个特定的printf语句中，使用"*str"作为"%s"的参数是错误的，会导致编译错误。
第6章 数组 指针与字符串（郑莉 C++语言程序设计（第4版））
11-29
本书针对程序设计的初学者，以面向对象的程序设计思想为主线，以通俗易懂的方法介绍C++语言，引导读者以最自然的方式，将人类习惯的面向对象的思维方法运用到程序设计中。主要内容包括程序设计基础知识、类与对象的...
C++ 课程作业 第六章 数组指针与字符串2——vector类（图书管理）
04-16
一、请设计一个Book类（与动态数组类的要求一致）： 1、包括私有成员： unsigned int m_ID;//编号 string m_Name;//书名 string m_Introductio//简介 string m_Author;//作者 string m_Date;//日期 unsigned ...
C语言 12 函数
天河有尽后为涯，星海无边前作岸。
09-13 1108
程序的入口点就是main函数，只需要将程序代码编写到主函数中就可以运行了，不过这个函数只是由我们来定义，而不是我们来调用。当然，除了主函数之外，一直在使用的printf那么，函数的具体定义是什么呢？函数是完成特定任务的独立程序代码单元。每次要做这个任务时，都要完完整整地将任务的每一行代码都写下来，如果程序中多处都需要执行这个任务，每个地方都完整地写一遍，实在是太臃肿了，有没有一种更好的办法能优化代码呢？
CF C. Nikita and LCM
qq_74190237的博客
09-13 272
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C++与QML的数据交互
qq_50679120的博客
09-11 528
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
C++_map_set详解
最新发布
2302_77644537的博客
09-16 648
set是按照一定次序存储元素的容器在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格的排序准则（默认是小于）进行排序。set在底层是用二叉搜索树(红黑树)实现的。map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 565
继续学习头文件的数学函数。
C++ 中 vector 的常用功能介绍
2202_75569688的博客
09-12 429
在 C++ 中，vector是一种常用的动态数组容器，提供了方便的自动扩展、内存管理以及各种便捷的操作方法。它是 C++ 标准模板库（STL）的一部分，适用于需要动态存储和管理大量元素的场景。在本文中，我们将简要介绍vector的常用功能，展示如何对其进行操作和排序。为了简洁起见，假设我们已经使用了。
【C++ && Qt day11】
wzj46的博客
09-11 275
2、头文件窗口文件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值