类和动态内存分配(2)

已于 2023-01-23 21:24:42 修改
阅读量590 收藏 1
点赞数 1
分类专栏： C++ C++ Primer Plus 文章标签： c++ 开发语言
于 2022-08-23 16:52:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GodFishhh/article/details/126483820
版权

目录

1.指向对象的指针

2.使用定位new运算符为对象分配内存空间

1.指向对象的指针

// class.h

#pragma once

#ifndef _CLASS_H_
#define _CLASS_H_

#include<iostream>
using std::istream;
using std::ostream;

class String
{
private:
	char* str;   //字符串指针，此处没有分配内存，后续用new来为其开辟内存空间
	int len;
	static int num_strings;  //只有static,则必须声明后在实现文件中进行初始化
	static const int CINLIM = 80; //const static 可以直接在类中初始化
public:
	String(const char* s);
	String();
	String(const String& s);//赋值构造函数
	~String(); //在使用new的类中十分重要 -- 配套使用delete来释放堆空间
	int length() const
	{
		return len;
	};
	String& operator=(const String& st); //对象赋值
	String& operator=(const char* s);  //一般字符串赋值
	char& operator[](int i); //重载 中括号[] 运算符   //可改变数据版本
	const char& operator[](int i)const;  //不改变数据版本
	friend bool operator<(const String& st1, const String& st2);
	friend bool operator>(const String& st1, const String& st2);
	friend bool operator==(const String& st1, const String& st2);
	// ostream流和istream流没有共用的复制构造函数，所以必须要返回引用且按引用传递参数，若返回的是一个值或者按值传递参数，则使用到了副本且必须使用复制构造函数。
	friend istream& operator>>(istream& is, String& st);  // cin>>
	friend ostream& operator<<(ostream& os, const String& st);  // cout<<
	//静态函数
	static int HowMany();
};

#endif

// fuc.cpp

#include<cstring>   // strcpy--复制字符串, strcmp--根据ASCII码值比较字符串，strlen--获取字符串的长度
#include"class.h"
using namespace std;

//为类中声明的static变量初始化，且要声明其所在的类区域
int String::num_strings = 0;

int String::HowMany()
{
	return num_strings;
}

String::String(const char* s)
{
	len = std::strlen(s);  //strlen获取的是字符串除去末尾空字符的长度,所以长度要为 len+1;
	str = new char[len + 1];  //在构造函数中使用new申请堆空间，在析构函数中使用delete释放堆空间
	strcpy(str, s);
	num_strings++;
}

String::String()
{
	len = 4;
	str = new char[len + 1];
	str[0] = '\0';  //设置为空指针，也可为设置为 NULL, nullptr,(void *)0q	
	num_strings++;
}

String::String(const String& s)//复制构造函数
{
	num_strings++; //为新初始化的对象复制，所以可以在总数上加上1
	len = s.len;
	//深度复制:
	str = new char[len + 1];
	strcpy(str, s.str);
}

String::~String() //在使用new的类中十分重要 -- 配套使用delete来释放堆空间
{
	--num_strings;
	delete[] str;
}

String& String::operator=(const String& st) //对象赋值
{
	if (this == &st)  //如果调用对象和参数已经相同
	{
		return *this;
	}
	delete[] str; //先删除之前的内存，防止内存的浪费
	len = st.len;
	//深度复制
	str = new char[len + 1];
	strcpy(str, st.str);
	return *this;  //使得可以进行连续复制操作
}

String& String::operator=(const char* s)  //一般字符串赋值
{
	delete[] str;
	len = strlen(s);
	str = new char[len + 1];
	strcpy(str, s);
	return *this;
}

char& String::operator[](int i) //重载 中括号[] 运算符   //可改变数据版本
{
	return str[i]; //即返回调用对象字符串的第i个字符
}

const char& String::operator[](int i)const//不改变数据版本
{
	return str[i];
}

//友元函数:
bool operator<(const String& st1, const String& st2)
{
	return (strcmp(st1.str, st2.str) < 0);
}

bool operator>(const String& st1, const String& st2)
{
	return st2 < st1;  //直接使用上面刚重载的运算符 逻辑：若语句为: st1>st2,若成立则应当有st2<st1,可以实现函数功能
	//或 return (strcmp(st1.str,st2.str)>0)
}

bool operator==(const String& st1, const String& st2)
{
	return (strcmp(st1.str, st2.str) == 0);
}

istream& operator>>(istream& is, String& st) // cin>>
{
	char temp[String::CINLIM]; //友元函数，不能直接使用类中的静态常量，需要使用作用域解析运算符
	is.get(temp, String::CINLIM); // 相当于cin,get(name,size)
	if (is)
	{
		st = temp;  //使用的重载过的对于常规字符串的赋值运算符
	}
	//while的作用：读取掉剩下的多余出来的字符
	while (is && is.get() != '\n')   // 若输入失败，则istream对象is的值将被置为false;
	{
		continue;
	}
	return is;
}

ostream& operator<<(ostream& os, const String& st)  // cout<<
{
	os << st.str;
	return os;
}

// main.cpp

#include<iostream>
#include<cstdlib>
#include<ctime>
#include"class.h"
const int Arsize = 10;
const int MaxLen = 81;

int main()
{
	using namespace std;
	String name;
	cout << "Hi, what's your name?" << endl;
	cin >> name;  // >>运算符的重载，使可以作用于对象

	cout << name << ", please enter up to " << Arsize
		<< " short sayings <empty line to quit>:" << endl;  // <<运算符的重载，使可以作用于对象
	String sayings[MaxLen];
	char temp[MaxLen];
	int i;
	for (i = 0; i < Arsize; i++)
	{
		cout << i + 1 << ": ";
		cin.get(temp, MaxLen);   // cin.get(stringname,stringlength)
		while (cin && cin.get() != '\n')   //当没有输入错误且没有读取完多余的字符时，继续循环读取
		{
			continue;
		}
		if (!cin || temp[0] == '\0')   //如果输入为空, break退出
		{
			break;
		}
		else
		{
			sayings[i] = temp;
		}
		int total = i;

		if (total > 0)
		{
			cout << "Here are your sayings: " << endl;
			for (i = 0; i < total; i++)
			{
				cout << sayings[i] << endl;
			}
			//使用指向对象的指针来保存特殊的字符串
			String* shortest = &sayings[0];
			String* first = &sayings[0];
			for (i = 1; i < total; i++)
			{
				if (sayings[i].length() < shortest->length())
				{
					shortest = &sayings[i];
				}
				if (sayings[i] < *first)
				{
					first = &sayings[i];
				}
			}
			cout << "Shortest sayings: " << *shortest << endl;
			cout << "First alphabetically: " << *first << endl;
			srand(time(0)); //为rand()提供随机数种子    cstdlib和ctime头文件中的函数
			int choice = rand() % total;
			String* favorite = new String(sayings[choice]); 
			cout << "My favorite sayings: " << *favorite << endl;
			delete favorite;
		}
		else
		{
			cout << "Not much to say,eh?" << endl;
		}
		cout << "Bye~" << endl;
		return 0;
	}
}

知识点:

1.ostream流和istream流没有公共的复制构造函数，在重载此类的运算符时必须要返回引用且按引用传递参数。若返回的是一个值或者按值传递参数，则使用到了副本且必须使用复制构造函数。

eg: friend ostream& operator<<(ostream & os, const String & st)

2.创建指向对象的指针的语法: classname * name;  (与创建指向一般变量的指针语法是相同的)

3.使用指向对象的指针：  访问对象中的公共函数: name->fucname (间接访问使用 -> 而不是 '.')，使用(*name)来进行解引用。

4.String* favorite = new String(sayings[choice]) 和 String* favorite = new String[number]的区别：前者是为favorite这个指向对象的指针初始化为sayings[choice]，后者是创建一个指针数组，其中共有number个指针。

2.使用定位new运算符为对象分配内存空间

#include<iostream>
#include<string>
#include<new>
using namespace std;
const int BUF = 512;

class JustTesting
{
private:
	string words;
	int number;
public:
	JustTesting(const string& s = "Just Testing", int n = 0) //所有参数均为默认参数的自定义构造函数
	{
		words = s;
		number = n;
		cout << words << " constructed" << endl;
	};
	~JustTesting()
	{
		cout << words << " destroyed" << endl;
	}
	void Show() const
	{
		cout << words << " , " << number << endl;
	}
};
int main()
{
	char* buffer = new char[BUF]; //创建内存区

	JustTesting* pc1, *pc2;  //创建两个指向对象的指针

	pc1 = new(buffer) JustTesting;
	pc2 = new JustTesting("Heap1", 20);  //普通new，并进行初始化

	cout << "Memory block addresses:\n" << "buffer: "
		<< (void*)buffer << " heap: " << pc2 << endl;
	cout << "Memory contents: \n";
	cout << pc1 << ": ";
	pc1->Show();
	cout << pc2 << ": ";
	pc2->Show();

	JustTesting* pc3, * pc4;
	pc3 = new(buffer + sizeof(JustTesting)) JustTesting("Better idea", 6);
	pc4 = new JustTesting("Heap2", 10);

	cout << "Memory contents: " << endl;
	cout << pc3 << ": ";
	pc3->Show();
	cout << pc4 << ": ";
	pc4->Show();

	delete pc2;
	delete pc4;

	//对于使用定位new分配内存的对象，必须要显式的调用析构函数来销毁对象,且删除顺序应当与创建的顺序相反 -- 先进后出，后进先出
	//同时，应当先销毁对象，再释放为其分配的内存空间
	pc3->~JustTesting();
	pc1->~JustTesting();
	delete[]buffer;

	cout << "Done!" << endl;
	return  0;

}

知识点:

1.如果自定义了构造函数则必须定义一个默认构造函数，但若是自定义的构造函数中的所有参数都是默认参数，则无需再定义一个默认构造函数。 

   eg: JustTesting(const string &s = "just testing",int n =0) -- 所有参数都有默认值

2.使用定位new需要包含头文件<new>

3.定位new的语法：typename * name = new (buffer) typename

  eg:JustTesting * pc1 = new(buffer) JustTesting;

4. 若多个对象使用一个buffer缓冲区，则需要加上偏移量( sizeof() )，防止内存的覆盖

  eg:JustTesting * pc3 = new(buffer + sizeof(JustTesting)) JustTesting("Better idea", 6);

5.对于使用定位new分配内存的对象，必须要显式的调用析构函数来销毁对象,且删除顺序应当与创建的顺序相反 -- 先进后出，后进先出。同时，应当先销毁对象，再释放为其分配的内存空间。

  eg:pc3->~JustTesting();
       pc1->~JustTesting();
       delete[]buffer;

GodFishhh
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
类继承（动态内存分配）
11-09
类继承和动态内存分配是C++编程中两个重要的概念，它们在实际开发中结合使用时，可以实现更灵活和高效的设计。在这个主题中，我们将深入探讨如何在类继承的环境中运用动态内存分配，并通过示例代码来理解这三种情况...
【C++】关于std::ostream的构造函数
吾志所往，所向披靡
01-11 9529
参考博客：https://blog.csdn.net/e21105834/article/details/115859154 一、问题 写了一段代码相对输出流std::osteam进行操作，可是却一直报错，代码如下： #include <iostream> #include <sstream> #include <string> using namespace std; int main(int argc, char* argv[]) { ostre
C++学习笔记5
qq_50299271的博客
10-13 900
C++学习笔记
ostream头文件
m0_68927910的博客
04-17 1837
ostream是什么 ostream也是信息流，控制输出 ostream怎么用 单用ostream似乎只能用来解hello world （程序懒得写，自己写去） ostream缺失 在C:\Program Files (x86)\Dev-Cpp\MinGW64\lib\gcc\x86_64-w64-mingw32\4.9.2\include\c++添加一个叫ostream的文件（不加后缀名），用c++打开后粘贴如下代码后编译即可修复 // Output streams -*- C++ -*-
c++ 学习笔记
guchaono1的专栏
04-25 1328
stack and heap: 栈与堆https://www.cnblogs.com/williamjie/p/11164022.html 这里说的栈与堆是操作系统中的概念与数据结构中的栈与堆不同。 heap：程序员操作，由malloc，memset之类函数分配的空间所在地。地址是由低向高增长的。一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 stack：编译器自动操作，以及函数调用的时候所使用的一些空间。地址是由高向低减少的。 POD: plain old data .....
如何从std :: ostream派生实现自定义的输出流类
aflyeaglenku的博客(QQ1010316426）
07-14 3248
本文为博主原创文章，未经博主允许不得转载。（合作洽谈请联系QQ：1010316426） 缘起： 笔者的项目产品上一般使用C风格的库记录运行日志，日志库的接口是如printf样式。近日，需要引入其他模块（不同途径获取）的代码，但是发现这个模块记录日志是使用C++的流式风格。因代码里巨大，手动修改费时费力（不符合程序员做事风格），于是笔者想到是否可以将流式的log只通过替换其日志宏 从而实现在不修改代码的前提下将流式转为printf式，从而完成log部分的整合。 //printf风格 void write_.
C++之继承和动态内存分配
12-22
如果基类使用动态内存分配，并重新定义赋值和复制构造函数，这将如何影响派生类的实现呢？这取决于派生类的属性，如果派生类也使用动态内存分配，这将如何实现呢？这种大致分为两种情况， 　第一种情况：派生类不...
C语言 动态内存分配的详解及实例
12-31
(1)malloc 和 free 用于执行动态内存分配的释放 (2)malloc 所分配的是一块连续的内存 (3)malloc 以字节为单位,并且返回值不带任何的类型信息:void* malloc(size_t size); (4)free 用于将动态内存归还系统:
C++ 中继承与动态内存分配的详解
12-26
例如,如果基类使用动态内存分配，并重新定义赋值和复制构造函数，这将怎样影响派生类的实现呢？这个问题的答案取决于派生类的属性。如果派生类也使用动态内存分配，那么就需要学习几个新的小技巧。下面来看看这两种...
浅谈C++内存分配及变长数组的动态分配
09-01
接下来，我们讨论`new`和`malloc`等动态内存分配方法： `new`是C++特有的运算符，用于动态分配对象和数组。例如： ```cpp int *a = new int; // 分配单个int int *b = new int(5); // 分配并初始化为5的int int *c ...
C++ ostream_iterator简单使用
最新发布
CHNIM的博客
08-23 730
ostream_iterator使用
C++语言中ostream
lijun5635的专栏
11-30 9695
#include是标准的C++头文件，任何符合标准的C++开发环境都有这个头文件。 在旧的标准C++中,使用#includeiostream.h> 但在新标准中,用#include，而且在VC中编程的同时要注意要添加： using namespace std; 在C++中，输入输出流被定义为类。C++的I/O库中的类称为流类(stream class)。用流类定义的对象称为
C++ 名称空间与友元函数
m0_46834622的博客
03-07 1136
摘要：当类的声明在名称空间内时，友元函数的声明和定义发生变化 1、当类的声明不在名称空间内时 class Test { private: int number; public: Test() { this->number = 1; } friend std::ostream &operator<<(std::ostream &os, Test &T); }; std::ostream &operator<<(st
使用std::ostream(nullptr)控制日志输出等级
robinfoxnan的专栏
04-26 565
日志需要按当前设置的级别来控制是否输出到文件或者控制台，这里做一个最简单示范： 随便设置日志级别： // 切换输出的技巧 enum LogLevel { LOGLEVEL_TRACE = 0, LOGLEVEL_DEBUG, LOGLEVEL_DETAIL, LOGLEVEL_INFO, LOGLEVEL_WARN, LOGLEVEL_ERROR, LOGLEVEL_FATAL, LOGLEVEL_OFF, }; 精心定义一个空的输出： class nullstream : pu
std::ostream_iterator、std::cout、std:copy实现输出
danshiming的博客
08-20 758
如下： std::vector<int> myvector(10); /* std::iota算法功能是从0每次自增1直至将myvector中的10个元素填满 故现在myvector中的元素为0,1,2,3,4,5,6,7,8,9 */ std::iota(myvector.begin(), myvector.end(), 0); // 将myvector中的所有按每隔一个空格输出到控制台，这里也可将空格换为其它字符，如：回车换行 std::copy(myvector.begin
C++ 类 sizeof 计算大小 虚函数 虚继承 虚基类 虚函数表
neninee的博客
09-15 2569
文章目录c++类的大小计算关于类/对象大小的计算一.简单情况的计算二.空类的大小三.含有虚函数成员（1）在派生类中不对基类的虚函数进行覆盖，同时派生类中还拥有自己的虚函数在派生类中对基类的虚函数进行覆盖（3）多继承：无虚函数覆盖（4）多重继承，含虚函数覆盖四.虚继承的情况 c++类的大小计算 c++中类所占的大小计算并没有想象中那么简单，因为涉及到虚函数成员，静态成员，虚继承，多继承以及空类等，不同情况有对应的计算方式，在此对各种情况进行总结。 首先要明确一个概念，平时所声明的类只是一种类型定义，它本身是没
C++必须用初始化列表进行初始化的场景
zgcjaxj的博客
05-26 703
《C++ Primer》 P258 7.5.1构造函数初始化列表 一节 类成员为const类型(const 类型在 C++11中，还可以使用 类内初始化方式，也就是直接在声明的时候进行初始化) 类成员为引用类型 const对象或引用只能初始化但是不能赋值。构造函数的函数体内只能做赋值而不是初始化，因此初始化const对象或引用的唯一机会是构造函数函数体之前的初始化列表中。 从无到有叫初始化，初始化（调用拷贝构造函数）创建了新对象；赋值（调用赋值操作符）没有创建新对象，而是对已有的对象赋值。 ...
c++11 标准模板（STL）（std::basic_ostream）（二）
qq_40788199的博客
07-01 265
全局对象 std::cout 和 std::wcout 控制到实现定义类型流缓冲的输出，它与标准 C 输出流 stdout 关联。 全局对象 std::cerr 和 std::wcerr 控制到实现定义类型的流缓冲，与标准 C 错误输出流 stderr 关联。 全局对象 std::clog 和 std::wclog 控制实现定义类型的流缓冲，与标准 C 输出流 stderr 关联，但不同于 std::cerr/std::wcerr ，不自动冲入这些流，且不自动与 cout tie() 。
C++基础教程面向对象（学习笔记（64））
qq_41879485的博客
11-10 472
综合测验 因此，我们通过C ++的继承和虚拟功能的旅程即将结束。亲爱的读者，不要担心，因为在我们前进的过程中还有许多其他C ++领域需要探索。 章节总结 C ++允许您设置基类指针和对派生对象的引用。当我们想要编写一个可以处理从基类派生的任何类型的对象的函数或数组时，这非常有用。 如果没有虚函数，基类指针和对派生类的引用只能访问基类成员变量和函数版本。 虚函数是一种特殊类型的函数，它解析为基类和派...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值