c++基础动态内存结构体字符串

最新推荐文章于 2024-11-10 00:19:26 发布
最新推荐文章于 2024-11-10 00:19:26 发布
阅读量956 收藏 2
点赞数
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55387802/article/details/126554180
版权

动态空间申请

静态分配

1、在程序编译或运行过程中，按事先规定大小分配内存空间的分配方式。int a [10]；
2、必须事先知道所需空间的大小。
3、分配在栈区或全局变量区，一般以数组的形式

动态分配

1、在程序运行过程中，根据需要大小自由分配所需空间。
2、按需分配。
3、分配在堆区，一般使用特定的关键字进行分配

new和delete

new申请堆区空间 ,delete释放空间

int *p = NULL;
p = new int;//从堆区申请int类型大小的空间
*p = 100;
cout<<"*p="<<*p<<endl;//100
//释放空间
delete p;
//new申请空间的同时 初始化空间内容
int *p1 = NULL;
p1 = new int(100);
cout<<"*p="<<*p<<endl;//100
delete p1;

new和delete操作数组空间

#include<iostream>
using namespace std;
int main()
{
    int *p=NULL;
    p=new int[5]{1,2,3,4,5};//new与[]结合表示申请数组空间
    int i=0;
    for (;i<5;i++)
    {
        cout<<p[i]<<endl;
    }
    delete [] p;// delete释放的时候也需要[]
    return 0;
}

字符串处理函数

以str开头的字符串处理函数 默认遇到’\0’结束操作

#include <string.h> //必要的头文件

测量字符串的长度 strlen

#include <string.h>
size_t strlen(const char *s);
s指 需要测量字符串的首元素地址
char str1[128]="hello";
strlen(str1);//5
char str2[128]="he\0llo";
strlen(str2);//2

字符串拷贝函数 strcpy与strncpy

#include <string.h>
char *strcpy(char *dest, const char *src);
char *strncpy(char *dest, const char *src, size_t n);
dest:目的空间地址
src：原字符串的首元素地址

char dst[128]="";
char src[]="hello\0world";
strcpy(dst,src);
cout<<dst<<endl;//hello

char dst1[]="";//dst1数组只有1字节 当src1拷贝到dst1中 造成溢出（内存污染）
char src1[]="helloworld";
strcpy(dst1, src1);
cout<<dst1<<endl;//hello world(污染内存)

字符串追加函数strcat与strncat

#include <string.h>
char *strcat(char *dest, const char *src);
char *strncat(char *dest, const char *src, size_t n);
将src指向的(前n个字符)字符串 追加到 dest指向的字符串尾部


char dst[128]="hello";
char src[]="world";
strcat(dst,src);
cout<<dst<<endl;//helloworld

char dst[128]="hello";
char src[]="world";
strncat(dst,src,3);
cout<<dst<<endl;//hellowor

字符串比较strcmp

include <string.h>
int strcmp(const char *s1, const char *s2);
int strncmp(const char *s1, const char *s2, size_t n);
返回值：
>0 s1字符串 > s2字符串
<0 s1字符串 < s2字符串
==0 s1字符串==s2字符串
比较的是字符的ascii码值，依次比较，

结构体

将不同类型的数据组合成一个有机的整体

利用struct关键字 可以将不同类型封装在一起，形成新的结构叫做"结构体"

定义结构体

struct 结构体类型名
{
成员列表;
};//注意此处有分号

//定义结构体类型
//系统不会为结构体类型开辟空间 只会为结构体类型定义的变量开辟空间
struct Student
{
int num;//结构体成员,定义结构体类型时 不要给成员初始化值
char name[32];
};
//结构体中的成员拥有独立的空间
//结构体定义变量
Student lulu;//lulu为结构体变量名
Student bob;//bob为结构体变量名

结构体变量的初始化

结构体变量不初始化, 变量中的成员内容不确定（随机值）

结构体变量的初始化 必须遵循成员的顺序以及成员自身的数据类型

struct Student
{
int num;//结构体成员
char name[32];
};
Student lulu={100,"lulu"};
cout<<lulu.num<<" "<<lulu.name<<endl;//100 lulu

memset清空整个结构体变量

void *memset(void *_Dst,int _Val,size_t _Size);
将地址从_Dst开始 长度位_Size的所有字节赋值位_Val

#include<string.h>
struct Stu
{
int num;
char name[32];
};
int main()
{
Stu lulu;
//清空整个结构体变量
memset(&lulu, 0, sizeof(lulu));//未初始化的成员是随机值，使用memset进行赋值0
cout<<lulu.num<<" "<<lulu.name<<endl;
}

给结构体变量中成员赋值

#include<iostream>
#include <string.h>
using namespace std;
struct Stu
{
int num;
char name[32];
};
int main()
{
Stu lulu;
memset(&lulu, 0,sizeof(Stu));
cout<<"请输入学号 姓名:";
cin>>lulu.num>>lulu.name;
cout<<lulu.num<<" "<<lulu.name<<endl;
return 0;
}

单独操作结构体中成员 必须遵循结构体自身的类型

#include<string.h>
struct Stu
{
int num;
char name[32];
};

Stu lulu ={100,"lulu"};
lulu.num += 100;//num是int类型
//name成员时数组名 位符号常量 不允许用=给name赋值，要用字符串替换
//lulu.name = "bob";//err
strcpy(lulu.name, "bob");

相同类型的结构体变量 之间赋值方法

Stu lulu = {100,"lulu"};
Stu bob;
#if 0
//第一种方法：逐个成员赋值(遵循成员类型)
bob.num = lulu.num;
strcpy(bob.name, lulu.name);
#elif 1
//第二种方法：相同类型的结构体变量 可以直接赋值
bob = lulu;
#else
//第三种方式：内存拷贝（是第二种的底层实现）
memcpy(&bob, &lulu, sizeof(Stu));
#endif
cout<<bob.num<<" "<<bob.name<<endl;//100 lulu

结构体嵌套结构体

结构体嵌套结构体 注意访问到最底层

struct Date
{
int year;
int month;
int day;
};
struct Student
{
int num;
char name[32];
Date ob;
};
Student lulu;
cout<<lulu.num<<" "<<lulu.name<<endl;
cout<<lulu.ob.year<<" "<<lulu.ob.month<<" "<<lulu.ob.day<<endl;

结构体数组

结构体数组：本质是数组 只是数组的每个元素位结构体变量

#include<iostream>
#include <string.h>
using namespace std;
struct Stu
{
int num;
char name[32];
};
int main()
{
    Stu arr[2]={{100,"lulu"},
            {101,"caicai"}};

    int n=sizeof(arr)/sizeof(arr[0]);
    int i =0;
    memset(arr,0,sizeof(arr));   //清空结构体数组
    for(i=0;i<n;i++)             //给结构体数组赋值
    {
        cin>>arr[i].num;
        cin>>arr[i].name;
    }
    for(i=0;i<n;i++)            //遍历结构体数组
    {
    cout<<arr[i].num<<"\t"<<arr[i].name<<endl;
    }
    return 0;
}

结构体指针变量

结构体的指针变量：本质是变量 只是该变量 保存的是结构体变量的地址

#include<iostream>
#include <string.h>
using namespace std;
struct Stu
{
int num;
char name[32];
};
int main()
{
    Stu caicai={100,"caicai"};


    Stu* p=&caicai;
    cout<<(*p).name<<endl;             //结构体变量用.指针成员
    cout<<p->name<<endl;
    cout<<(&caicai)->name<<endl;        //结构体指针变量（地址）用->指针成员
    return 0;
}

结构体数组元素的指针变量

指针变量 保存结构体数组 元素的地址

#include<iostream>
#include <string.h>
using namespace std;
struct Stu
{
int num;
char name[32];
};
void InputArr(Stu*arr,int n)
{
    int i=0;
    for(i=0;i<n;i++)
    {
        cin>>arr[i].num;
        cin>>arr[i].name;
    }
}
void SortArr(Stu*arr,int n)
{
    int i=0,j=0;
    Stu tem;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n-1;j++)
        {
            if(arr[j].num>arr[j+1].num)
            {
                tem=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=tem;
            }
        }
    }
}

void OutputArr(Stu*arr,int n)
{
    int i=0;
    for(i=0;i<n;i++)
    {
     cout<<arr[i].num<<"\t"<<arr[i].name<<endl;
    }
}
int main()
{
    Stu arr[3];
    int n=sizeof(arr)/sizeof(arr[0]);
    memset(arr,0,sizeof(arr));

    InputArr(arr,n);  //键盘输入结构体数组

    SortArr(arr,n);   //排序

    OutputArr(arr,n);  //输出
    return 0;
}

结构体的指针成员

struct Stu
{
int num;
char *name;
};
Stu lulu = {100, "hello world"};

lulu.name保存的时"hello world"的首元素地址， 而"hello world"字符串本身存储在文字常量区

struct Stu
{
int num;
char *name;
};
Stu lulu;
lulu.num = 100;
lulu.name = new char[32];  //利用new在堆区中开辟空间
strcpy(lulu.name, "hello world");   //此时hello world保存在堆区中  
cout<<lulu.num<<" "<<lulu.name<<endl;
delete [] lulu.name;

结构体的浅拷贝

相同类型的结构体变量可以整体赋值，默认赋值方式为：浅拷贝
浅拷贝：将结构体变量空间内容 赋值一份 到另一个相同类型的结构体变量空间中
如果结构体中没有指针成员 浅拷贝 不会带来问题。
如果结构体中有指针成员 浅拷贝 会带来多次释放堆区空间的问题。

struct Stu
{
int num;
char *name;
};
Stu lulu;
lulu.num = 100;
lulu.name = new char[32];  //利用new在堆区中开辟空间
strcpy(lulu.name, "hello world");   
Stu caicai;
caicai=lulu;

delete [] lulu.name;    //lulu.name与caicai.name，指向的是同一个堆区空间
delete [] caicai.name;

结构体的深拷贝

如果结构体中有指针成员 尽量使用深拷贝
所谓的深拷贝，就是为结构体的指针成员 分配独立空间 然后再内容拷贝

Stu lulu;
lulu.num = 100;
lulu.name = new char[32];
strcpy(lulu.name, "hello world");

Stu caicai;
caicai.num = lulu.num;
caicai.name = new char[32];
strcpy(caicai.name,lulu.name);

cout<<caicai.num<<" "<<caicai.name<<endl;
delete [] lulu.name;
delete [] caicai.name;

结构体变量在堆区 结构体的指针成员也指向堆区

struct Stu
{
int num;
char *name;
};

Stu *p = new Stu;      //在堆区申请一个结构体空间

p->name = new char[32];//结构体中指针成员指向堆区

p->num = 100;      //成员num在堆区
strcpy(p->name, "hello world");   // 成员name也在堆区
cout<<p->num<<" "<<p->name<<endl;

delete [] p->name;//先释放结构体成员空间
delete p;//再释放结构体空间

结构体的对齐规则

char 1 字节

short 2字节

int long float 4字节

double 8字节

自动对齐规则

1、确定分配单位（一行分配多少字节）
结构体中最大的基本类型 长度决定。
2、确定成员的偏移量
成员偏移量 = 成员自身类型的整数倍。
3、收尾工作
结构体的总大小 = 分配单位整数倍

当结构体成员中出现数组的时候，可以看成多个变量。

成员偏移量 = 成员自身类型的整数倍。

short 2字节，起始内存编号是2的倍数

int long float 4字节，起始内存编号是4的倍数

double 8字节，起始内存编号是8的倍数

struct stu{
char a;
short b;
int c;
}temp;    //8个字节

struct stu{
char a;
int c;
short b;
}temp;    //12个字节

强制对齐规则

#pragma pack (value)时的指定对齐值value。注意value值为1 2 4 8 16

指定对齐值与数据类型对齐值相比取较小值

1、确定分配单位（一行分配多少字节）
分配单位 = min(结构体中最大的基本类型, value)
2、确定成员的偏移量
成员偏移量 = 成员自身类型的整数倍。
3、收尾工作
结构体的总大小 = 分配单位整数倍

#pragma pack(2)
struct stu{
char a;
int b;
} ;//默认占8个字节，value设定为2，则占6个字节，设定为1，则占5个字节

位段

在结构体中，以位为单位的成员，称之为位段(位域)。

struct stu{
unsigned int a:2; //定义a占2位
unsigned int b:6;//定义b占6位
unsigned int c:4;//定义c占4位
unsigned int d:4;//定义d占4位
unsigned int i;
} data;     //总sizeof占8字节，2+6+4+4=16位，两字节+（两字节）+四字节=8字节

不能对位段成员取地址，位段成员可能不够1字节

对位域赋值 不要操作 位域本身位的宽度

data.a =2//a的取值范围是00–11，转十进制是0–3
赋值时，不要超出位段定义的范围;如段成员a定义为2位，最大值为3,即（11）2，所以data.a =5，就会取5（101）的低两位进行赋值01

位段的长度不能大于存储单元的长度

char a:9;//char 1个字节最多8位，

另起一个储存单元

unsigned char b:2;
unsigned char :0;//作用是使下一个位段从,下一个存储单元开始存放
unsigned char c:3;(另一个单元)

无意义位段

unsigned a: 1;
unsigned : 2;//可以定义无意义位段
unsigned b: 3;

共用体union

结构体：所有成员拥有独立空间

共用体：所有成员共享同一块空间

共用体关键字：union

共用体的空间 是由最大的成员类型决定

成员共享同一块空间，但是每个成员 能操作的空间的范围 是由成员自身类型长度决定。

union Data
{
char a;
short b;
int c;
};
Data ob;
ob.c = 0x01020304;   //ob.c:01020304  ob:b:0304  ob.a =04
ob.b = 0x0102;  	//ob.c:01020102  ob:b:0102  ob.a =02
ob.a = 0x01;		//ob.c:01020101  ob:b:0101  ob.a =01
cout<<ob.a+ob.b+ob.c<<endl;//0x01020203

枚举 enum

枚举:将枚举变量 要赋的值 一一列举出来

enum 枚举类型名{
枚举值列表（枚举元素）；
};

枚举值是常量,不能在程序中用赋值语句再对它赋值

枚举元素本身由系统定义了一个表示序号的数值，默认是从0开始顺序定义为0，1，2…

可以改变枚举值的默认值

enum week 
{
	mon,tue,wed,thu,fri,sat,sun   //0,1,2,3,4,5,6,7
};
enum week 
{
	mon=2,tue,wed,thu,fri=1,sat,sun //2,3,4,5,1,2,3改变枚举值的默认值
};
oragnelove
关注
结构体，字符串的使用
北聖
10-26 2329
C语言笔记字符串结构体定义结构结构体变量的初始化访问结构成员结构作为函数参数指向结构的指针位域位域的定义和位域变量的说明对于位域的定义尚有以下几点说明：位域的使用 牛客网-传送门： 字符串 结构体 字符串 C 语言中，字符串实际上是使用 null 字符 ‘\0’ 终止的一维字符数组。 下面一个小实例 #include <stdio.h> int main () { char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'}; printf
C/C++学习笔记五（结构体、字符与字符串）
炫目萧萧的专栏
08-03 2754
结构体C语言中复杂的数据结构都需要使用结构体表示，在这里说一下结构体的使用要点。结构体内存分布以及对齐问题编译器在为结构体分配内存时，并不会分配和所有成员数据长度和恰好相等的内存空间，而是会考虑到计算机cpu的读取性能，对结构按照某个模数（alignment modulus）进行对齐。例如结构体中拥有int （4个字节），char（1个字节）两个变量，但在使用sizeof进行大小输出时，并不是简单的
C++数据结构之字符串
suren_jun的博客
10-28 635
这里是C++数据结构的字符串，主要是对字符串的一个总结，以及一些基础操作，还详细讲解了单字符串匹配和多模式匹配算法，详情可以跳转链接进入。废话说到这里，开始上干货。
new和malloc可申请的空间大小以及智能指针和C++循环引用
最新发布
ll923116的博客
11-10 734
在这个例子中，student1通过shared_ptr持有course1的引用（在student1->courses向量中），同。shared_ptr引用Student对象，能够控制Student对象的生命周期，而Student对象通过weak_ptr引。当file_ptr的引用计数为0时，shared_ptr内部维护一个引用计数，用于记录有多少个shared_ptr对象指向同一个底层对象。这行代码创建了一个shared_ptr对象p1，它指向一个新分配的int类型对象，该对象的值被初始化为。
结构体中使用string
bees007的专栏
08-16 4642
1. malloc只是负责申请一块内存，没有任何其他动作。 2. 直接声明结构体或者new 一个结构体指针，会调用默认构造函数。如果结构中包含类，同样会调用成员类的默认构造函数。 3. 你程序中的内存错误是因为使用malloc分配一个结构体内存，但是string是一个类。并没有调用string的构造函数，所以string在malloc之后没有正确构造，导致使用时段错误。   -------
数据结构-字符串(string)(c++)
m0_58966334的博客
05-09 248
#include<iostream> //string类的基本实现 class String { public: String(int max = 10); //默认构造 String(const char* str); //常量构造 String(const String& str); //拷贝构造 String(int num, char str); //字符构造 void print(); //输出数组 ..
c++数据结构：字符串
qq_45303986的博客
10-14 476
字符串或串(String)是由数字、字母、下划线组成的一串字符。一般记为 s=“a1a2···an”(n>=0)。它是编程语言中中表示文本的数据类型。字符串在存储上类似字符数组，它每一位单个元素都是能提取的，字符串的零位是它的长度，如s[0]=10，这提供给我们很多方便，例如高精度运算时每一位都能转化为数字存入数组。
C—结构体，动态分配内存存储字符串
勇敢牛牛
11-06 504
C语音，字符串大小不固定，动态分配内存
（二）C++基础 动态内存
脸滚键盘
10-11 1079
一、目的和要求 1.熟练掌握数组的使用方法 2.掌握指针的使用方法 1.熟练掌握动态内存分配与释放 2.掌握基本算法的实现 二、具体内容 1.给定一个整数数组，找出两个元素的和等于给定值的数对，并统计符合条件的数对的个数，如果没有满足条件的数对，返回0。 例如给定数组[1, 5, 7, 5, 8, 9, 11, 12]，给定数值12，那么，满足条件的数对共有3对，分别是(1,11)，(5,7)，(...
在json字符串和c++对象之间进行转换。json字符串和c++结构体之间互相转换- xyz347 / x2struct
01-27
项目“x2struct”包含的主要功能是解析JSON字符串并将其内容映射到C++的结构体中，同时也可以将C++结构体转换回JSON字符串。这个过程通常被称为序列化和反序列化。序列化是将C++对象的状态转换为可存储或可传输的...
C#调用C++动态库，执行回调函数并传递结构体参数
12-25
本文将详细探讨如何在C#中调用C++编写的动态链接库（DLL），执行回调函数并传递结构体参数。这涉及到.NET Framework的P/Invoke（Platform Invoke）技术以及对C++内存管理和调用约定的理解。 首先，C#调用C++动态库...
C++基础入门教程（三）：数组、字符串、结构体、共用体
09-04
字符串在C++中有两种形式，C风格的字符数组和更现代的`std::string`类。C风格字符串需要以空字符'\0'结尾，而`std::string`提供了更多便捷的操作，如赋值、连接等。原始字符串简化了包含特殊字符的字符串的创建。...
c语言 结构体转json,关于在C++中结构体与Json字符串互转的问题
weixin_31129503的博客
05-19 1053
大家有没有在项目中遇到过，将一些预定义的本地结构体转换为Json字符串后，发送到网络中的情形。那我猜想下大家常规的做法：写一个函数，传入结构体的指针，然后在函数中对结构体的每一个成员根据其类型，使用Json类库的赋值方法，直接或间接创建Json子对象，组成一个内存树状结构，最后调用Json类库的方法生成字符串。这样的做法似乎比较完美，工作完成得很好，确实也挑不出什么毛病来，让我们先看看在golan...
C++数据结构——字符串
GeekZW的博客
06-28 5717
                                     C++数据结构——字符串   参考博客或网址： （1）菜鸟教程——C++字符串 （2）https://blog.csdn.net/ylh1234/article/details/64929992 （3）https://blog.csdn.net/fenxinzi557/article/details/5145782...
C++学习之使用结构体(对比C语言)（C语言字符串本质就是字符指针）
阿乐的博客
09-18 383
通过写这个结构体，也复习了好多C语言知识 场景： 学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求如下： 设计学生和老师的结构体(类)，其中在老师的结构体（类）中，有老师姓名和一个存放5名学生的数组作为成员，学生的成员有姓名、考试分数，创建数组存放3名老师，通过函数给每个老师及所带的学生赋值最终打印出老师数据以及老师所带的学生数据。 第一版代码：（好多C语言写法） #include<iostream> #include<string> #include<ctime
C++ 动态分配 结构体
jltxgcy的专栏
01-14 4565
一、C语言中结构体与指针，参考如下：          http://blog.csdn.net/jltxgcy/article/details/17226723 二、C++与C语言不同的地方在于动态分配结构体         C++推荐用new来代替malloc，delete来代替free struct s_options *opts = new (struct s_optio
C++动态结构练习
mingmingsuper的专栏
07-30 907
#include #include #include int caculateYadFromFurlong(int furlong); using namespace std; int main(void) { struct student { char name[20]; int age; }; student *stu = new student; cout <
结构体 使用string
wangxinyibj的博客
02-05 1396
结构体中尽量不要用string，原因是结构体是一个对象，如果使用malloc或memset会报错，如果非要用的话，只能用new。因为malloc只会申请内存，不会初始化。而new可以申请内存，也可以初始化。在c里没有new，new是后来在c++出现的，所以c++既可以用new也可以用malloc。如果非要用string的话，需要满足条件。1.使用new关键字，不能使用malloc。2.不能使用memset对对象进行初始化。
C++动态分配内存的字符串
kai46385076的专栏
12-15 3840
Mysring.h文件#ifndef MYSTRING_H #define MYSTRING_H#include <iostream>//一个单例的能够动态分配内存的字符串 class mystring { private: static mystring *self; char *s; public: static mystring *makestring(const ch
C++基础了解-29-C++ 动态内存
Xiaowu2048的博客
03-10 62
C++ 动态内存
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值