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

已于 2024-08-12 09:55:29 修改
阅读量909 收藏 13
点赞数 27
分类专栏： C++ 文章标签： c++ 开发语言
于 2024-08-11 23:44:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_71751116/article/details/140997819
版权

一、数组 

注意

  • 数组元素在内存中是顺序、连续储存的。 
  • 使用数组名传递数据时，传递的是地址。
  • 声明一个一维对象数组的语法形式：类名 数组名[ 常量表达式 ]；指定初始值，例如：
Location a[3]={Location(1, 2), Location(3, 4)};
//没有指定数组元素的初始值，就会调用默认构造函数

vector

vector 不是一个类，而是一个类模板。用vector定义动态数组的形式如下：

vector<元素类型> 数组对象名(数组长度);

例如：
int x= 10;   
vector<int>arr (x);  //大小为10的int型数组对象arr

注意

  •  初始化：普通数组未被初始化时，它的元素将具有不确定的值；vector创建了动态数组，并且在指定了大小的情况（或初始化列表）下，如果是 int型--->全初始化为0；类类型--->调用其默认构造函数。
  • 初值也可以自己指定，但只能为所有元素指定相同初值，形式为:
vector<元素类型>数组对象名（数组长度，初值）

例：

逆序：调用库函数

二、指针 

空指针---nullptr 

函数指针：

例如：

new delete 与 malloc free 区别 

  • 构造函数与析构函数：new 和 delete 操作符会自动调用对象的构造函数和析构函数 ；malloc 和 free 只是简单地分配和释放内存，不会调用任何构造函数或析构函数。
  • 类型转换：new 操作符则直接返回指向已分配内存并初始化的适当类型的指针，因此不需要类型转换；malloc 返回的是一个 void* 类型的指针，它表示未定义类型的内存块。因此，你需要将它转换为适当的类型才能使用。
  • 关键字与函数：new 和 delete 是C++中的关键字，它们由C++编译器直接支持，并具有特殊的语法和行为；malloc 和 free 则是C语言的标准库函数，通过包含头文件 <cstdlib> 来使用。

  

new创建：

int new(10) --- 默认创建一个，初始化为10；  ( ) ---> 初始化
int new[10] --- [ ]指定创建10个，未初始化。   [ ] ---> 创建个数

new delete: 

lamda表达式

[](){}; --> 短小函数就地编写

[capture](arguement){body} == [捕获](形参){函数体}

 

三、字符串

例子： 

append 追加字符串//扩容

this 版本 

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

class String
{
public:
    String(const char *p) : m_p(new char[strlen(p) + 1])
    {
        strcpy(m_p,p);
    }
    void show() const
    {
        cout << m_p << endl;
    }

    void append(const char *p)
    {
        char *q = new char[strlen(m_p)+strlen(p)+1];
        strcpy(q,m_p);//strcpy(q,this->m_p);
        strcat(q,p);
        delete []m_p;
        m_p = q;
    }

    void append(const String &other)
    {
        char *p = new char[strlen(this->m_p)+strlen(other.m_p)+1];
        strcpy(p,this->m_p);//hello
        strcat(p,other.m_p);//world
        delete []this->m_p;
        this->m_p = p;
    }

    size_t length() const
    {
        return strlen(m_p);
    }

private:
    char *m_p;
};

int main(void)
{
//    String s("Hello");
//    s.show();
//    cout << s.length() << endl;
//    s.append(" World");
//    s.show();
//    cout << s.length() << endl;
//    return 0;

    String a("Hello");
    String p(" World");
    a.show();
    cout << a.length() << endl;
    a.append(p);
    a.show();
    cout << a.length() << endl;

    return 0;
}

 

assign 修改字符串

this 版本

 

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

class String
{
public:
    String(const char *p) : m_p(new char[strlen(p) + 1])
    {
        strcpy(m_p,p);
    }
    void show() const
    {
        cout << m_p << endl;
    }

    void assign(const char *p)
    {
        char *q = new char[strlen(p) + 1];
        strcpy(q,p);
        delete []m_p;
        m_p = q;
    }

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

    size_t length() const
    {
        return strlen(m_p);
    }

private:
    char *m_p;
};

int main(void)
{
//    String b("Hello");
//    b.show();
//    cout << b.length() << endl;
//    b.assign("China!!!");
//    b.show();
//    cout << b.length() << endl;

    String q("Hello");
    String t("China!!!");
    q.show();
    cout << q.length() << endl;
    q.assign(t);
    q.show();
    cout << q.length() << endl;

    return 0;
}

代码总和 

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

class String
{
public:
    String(const char *p) : m_p(new char[strlen(p) + 1])
    {
        strcpy(m_p,p);
    }
    String(const String &other) : m_p(new char[strlen(other.m_p) + 1])
    {
        strcpy(this->m_p,other.m_p);
    }
    ~String()
    {
        delete []m_p;
    }
    void show() const
    {
        cout << m_p << endl;
    }

    void append(const char *p)
    {
        char *q = new char[strlen(m_p)+strlen(p)+1];
        strcpy(q,m_p);//strcpy(q,this->m_p);
        strcat(q,p);
        delete []m_p;
        m_p = q;
    }

    void append(const String &other)
    {
        char *p = new char[strlen(this->m_p)+strlen(other.m_p)+1];
        strcpy(p,this->m_p);//hello
        strcat(p,other.m_p);//world
        delete []this->m_p;
        this->m_p = p;
    }

    void assign(const char *p)
    {
        char *q = new char[strlen(p) + 1];
        strcpy(q,p);
        delete []m_p;
        m_p = q;
    }

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

    size_t length() const
    {
        return strlen(m_p);
    }

private:
    char *m_p;
};

int main(void)
{
//    String s("Hello");
//    s.show();
//    cout << s.length() << endl;
//    s.append(" World");
//    s.show();
//    cout << s.length() << endl;
//    return 0;

//    String a("Hello");
//    String p(" World");
//    a.show();
//    cout << a.length() << endl;
//    a.append(p);
//    a.show();
//    cout << a.length() << endl;

//    String b("Hello");
//    b.show();
//    cout << b.length() << endl;
//    b.assign("China!!!");
//    b.show();
//    cout << b.length() << endl;

    String q("Hello");
    String t("China!!!");
    q.show();
    cout << q.length() << endl;
    q.assign(t);
    q.show();
    cout << q.length() << endl;

    return 0;
}

 浅复制与深复制

浅复制：创建了一个新的对象，新对象中的某些成员只是简单地复制了原始对象中的指针值，即它们指向了内存中的相同位置。
深复制：不仅创建了一个新的对象，而且它还为原始对象中的每一个动态分配的内存块都分配了新的内存，并将原始数据复制到这些新的内存块中。这样，新对象和原始对象就完全独立了，对其中一个对象的修改不会影响到另一个对象。

链表 

头插

    void push_front(int n)
    {
        Node *pNew = new Node(n);
        pNew->next = pHead;
        pHead = pNew;
    }

尾插

    void push_back(int n)
    {
        if (isEmpty())
        {
            push_front(n);
        }
        else
        {
            Node *pNew = new Node(n);
            Node *p = pHead;
            while (p->next != nullptr)
            {
                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)
            {
                p = p->next;
            }
            delete p->next;
            p->next = nullptr;
        }
        else
        {
            pop_front();
        }
    }

深复制

    List(const List &other) : pHead(nullptr)//深复制
    {
        Node *p = other.pHead;
        while (p != nullptr)
        {
            this->push_back(p->data);
            p = p->next;
        }
    }

 代码总和

#include <iostream>
#include <cstdlib>
#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;
        }
    }
    ~List()
    {
        clear();
        cout << "~list" << endl;
    }

    void clear(void)
    {
        while (!isEmpty())
        {
            pop_front();
        }
    }
    void push_front(int n)
    {
        Node *pNew = new Node(n);
        pNew->next = pHead;
        pHead = pNew;
    }

    size_t size() const
    {
        size_t counter = 0;
        Node *p = pHead;
        while (p != nullptr)
        {
            counter++;
            p = p->next;
        }
        return counter;
    }

    bool isEmpty() const
    {
       return pHead == nullptr;
    }

    void show() const
    {
        Node *p = pHead;
        while (p != nullptr)
        {
            cout << p->data << ", ";
            p = p->next;
        }
        cout << "\b \n";//\b退格
    }

    void push_back(int n)
    {
        if (isEmpty())
        {
            push_front(n);
        }
        else
        {
            Node *pNew = new Node(n);
            Node *p = pHead;
            while (p->next != nullptr)
            {
                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)
            {
                p = p->next;
            }
            delete p->next;
            p->next = nullptr;
        }
        else
        {
            pop_front();
        }
    }
private:
    Node *pHead;
};

int main()
{
/*
//头插
    List l;
    cout << "size = "<< l.size() << endl;
    cout << "isEmpty = " << l.isEmpty() << endl;
    l.push_front(1);
    l.push_front(2);
    l.push_front(3);
    l.show();
    cout << "size = "<< l.size() << endl;
    cout << "isEmpty = " << l.isEmpty() << endl;
//尾插
    l.push_back(4);
    l.push_back(5);
    l.push_back(6);
    l.show();
//头删
    l.pop_front();
    l.pop_front();
    l.pop_front();
    l.show();
//尾删
    l.pop_back();
    l.pop_back();
    l.pop_back();
    l.show();
    cout << "isEmpty = " << l.isEmpty() << endl;
*/
    List l1;

    for (int i = 0; i < 1000; ++i)
    {
        l1.push_front(i);
    }
    l1.show();
    cout << "size = "<< l1.size() << endl;
    cout << "isEmpty = " << l1.isEmpty() << endl;

    List l2(l1);
    l2.show();
    return 0;
}

Yao_xiiiin.
关注
专栏目录
C++指针解读（6）-- 指针和字符串
10-15 764
字符串，及指向字符串的指针等相关概念。
C++学习笔记20：指针和字符串
半路出家的小白
09-24 257
在C++的多数表达式和 cout 中，char 数组名、char 指针以及用引号括起来的字符串常量都被解释为字符串第一个字符的地址。 下面的示例程序演示了如何使用不同形式的字符串，并通过注释指出了应尽量避免的错误使用指针的方式。 //ptrstr.cpp -- 使用不同形式的字符串 #include <iostream> #include <cstring> using namespace std; int main() { char anim...
图文并茂的C++指针、数组与字符串学习笔记
m0_73421035的博客
05-19 266
形参数组和实参数组的首地址重 合.后面的元素按照各自在内存中的存储顺序进行对应.对应元素使用相同的数据存储地 址,因此实参数组的元素个数不应该少于形参数组的元素个数。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D3YDm8ZU-1684500139359)(file:///C:/Users/Lenovo/AppData/Roaming/Typora/typora-user-images/image-20230505170702877.png?“找我请到302”。
C/C++ 字符串与指针
勇敢前进的ACMer
08-16 1075
1．字符串与字符串指针 字符串是存放在字符数组中的，通常将字符串作为一个整体来使用，用指针来处理字符串更加方便。 当用指向字符串的指针来处理字符串时，并不关心存放字符串的数组大小，而只关心是否已处理到字符串的结束符。 用指针实现字符串拷贝 　# include <iostream.h> 　# include <string.h> 　void main(void) { char *p1 =
C++ 指针&字符串
m_iyan的博客
12-01 1302
一级指针： char arr[]="hello"; char*p=arr; char arr[]="hello"; char*p=arr; *(p)='H'; 数组可退化为指针，指针能遍例,修改数组元素。 const 与 指针结合： char arr[] = "hello"; const char* p = arr;//arr数组元素不可修改； char* const p = arr;//p指针指向对象不可修改； 字符串的定义，特点： char arr[
第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++入门（9）数组、字符串、指针
qq_46298436的博客
05-05 374
（1）初识数组 数组，字符串，指针，这三个概念在C++中是毫不分割的关系。数组里可以包含各种各样的字符串，我们可以用指针去访问数组里的字符串。先从数组讲起吧。 数组是一种数据格式，它也是一种值，但是它可以储存多个相同数据类型的常量（或变量）。 声明数组时的三要素：储存在数组中的数据类型；数组名；数组中的元素数。例如：int months[6]。 中括号内要指定元素数目，它必须是整型...
C++ 课程作业 第六章 数组指针与字符串2——动态数组类（图书管理）
04-16
请设计一个程序实现图书库存的管理。请根据给定的main函数及程序输出，完成设计。具体要求如下。 一、请设计一个Book类： 1、包括私有成员： unsigned int m_ID;//编号 string m_Name;//书名 ...
C语言总结七：表示字符串的两种方式—字符数组与字符串指针详细总结
最新发布
weixin_47040031的博客
12-21 1975
C语言并没有专用的字符串类型的数据类型来存储一个字符串，字符串是C语言中重要的一块基本理论，掌握好字符串可减少实际开发经常出现的错误，本篇博客详细全面总结字符数组与字符串的定义及基本的使用方法，以及常用的库函数和针对内存操作的内存函数。
C++基础之字符串与指针
mazi的博客
07-31 4581
一、字符串 1、字符串默认用字符数组来存储。 2、strlen求字符串长度是不包括\0的 3、 char a[]={“Hello World!”};或 char a[]=”Hello World!” // ’\0’由计算机自动加上。char c3[3][5]={{ 'a','b','c','d','\0'},{'m','n','p','\0'},{'x','y','z'
C++ 指针知识点摘录
泰勒猫的博客
03-03 396
指针是 C 语言中的一个重要概念，也是 C 语言的一个重要特色。在 C 语言中，指针被广泛使用，它和数组、字符串、函数间数据的传递等有着密不可分的联系。可以说，没有掌握指针就没有掌握 C 语言的精华。 指针可以对内存中各种类型的数据进行快速、直接的处理，也可以为函数间的数据传递提供简洁、便利的方法。正确熟练地使用指针有利于编写高效的程序，但指针使用不当也容易导致严重错误。指针很灵活，也很危险。 定义指针变量 指针变量（简称指针）就是存放地址的变量。其声明形式与一般变量声明相比只是在变量名前多一个星号*，接下
C/C++ 字符数组(字符串)和指针总结(char *, string, Type *)
一些笔记
08-09 3568
对 C/C++ 字符串（数组）和指针做的总结
C++指针和字符串
weixin_68153081的博客
07-28 1521
C++指针和字符串以及存储类型
C++ 字符串指针和字符串指针数组详解
Kallou的博客
03-02 9335
C++处理字符串有两种方式，即：指针方式和数组方式 数组方式：char a[] = "HelloWorld"; 指针方式：const char* s= "HelloWorld"; const可以忽略 接下来详细讲解一下字符串指针 首先，为什么字符串可以直接赋值给指针，即char* s = "HelloWorld"不会报错，不应该是把字符串的地址赋值给指针吗？ 原因：这里的双引号做了3件事： 1.申请了空间(在常量区)，存放了字符串 2. 在字符串尾加上了'/0' 3.返回地址 为...
C++指针和字符串的详解。
u013070875的博客
01-17 4452
首先介绍类型：字符类型，字符数组类型，字符串类型string。 cin>>s,getline(cin,s).需要先清除输入的缓冲区。cin.clear(),cin.sync(); 字符类型的赋值：char c="j"; 字符数组有两种风格：C++风格，定义数组时必须确定数组大小和类型。 char a[7];若未初始化，则默认初始化为非定义，访问该值会引发错误。 char a[...
C++ 之字符串、字符数组与字符指针(*、**)
yohnyang的博客
11-16 923
C++ 之字符串、字符数组与字符指针(*、**)
【C++】指针与字符串的基础知识
weixin_30279751的博客
04-09 100
一.指针 使用指针访问数据*pValue需二次访存，第一次访存，得到存放该数据的地址pValue，第二次访存，得到该内存地址存放的数据*pValue 1.指针的声明和赋值 声明 dataType *pValue; 以整形为例 　　　 int count=5; int *pValue=&count; 或 int *pValue;...
清华大学郑莉教授讲解C++第6章：数组、指针与字符串
本章内容主要涵盖了C++中的核心概念，包括数组、指针、动态存储分配、指针与数组的关系、指针与函数以及字符串。这些知识点是C++编程的基础，对于理解和编写高效的C++程序至关重要。 1. **数组**：数组是C++中的一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值