C++ primer Plus 第十二章:类和动态内存分配

C++ primer Plus(第六版)第十二章 类和动态内存分配 章节编程练习答案 1.对于下面的声明: class Cow { char name[20]; char * hobby; double weight; public: Cow(); Cow(const char * nm, const char * ho, double wt); Cow(const Cow c&); ~Cow(); Cow & operator=(const Cow & c); void ShowCow() co... 阅读详情

12.1动态内存和类

12.1.1复习实例和静态类成员

12.1.2特殊成员函数

首先看这样一个例子

#include <iostream>
#include <cstring>
using namespace std;
class string1
{
private:
    char *str;
    int len;
public:
    string1(const char*);
    string1();
    ~string1();
    void display()
    {
        cout<<str<<endl;
    }
};
string1::string1()
{
   len=0;
   str=new char [1];//这里是为了,和析构函数里的 delete [] 匹配
   str[0]='\0';
}
string1::string1(const char*s)
{
    len=strlen(s);
    str = new char[len+1];
    strcpy(str,s);
}
string1::~string1()
{
    delete [] str;
    cout<<"析构函数被调用"<<endl;
}
string1 fun()
{
    string1 a("111");
    return a;
}
int main()
{
    string1 a=fun();
    a.display();
    return 0;
}

这个例子是错误的,对于类中不带指针类型成员变量的类来说可以使用这种函数返回赋值的方法,但是上面这个例子就不行了,因为在fun函数里,定义了一个局部对象,在离开函数时候,这个局部对象会被析构,所以函数将创建一个临时无名对象,这个临时无名对象会调用一个叫复制构造函数的构造函数,逐个赋值局部对象的非静态成员,它复制的是成员的值。

如果没有定义复制构造函数,程序会调用自己生成的默认复制构造函数

12.1.3使用程序提供的默认复制构造函数存在的问题

存在什么问题呢

这个临时无名对象里的东西跟局部对象一模一样,就连指针也一样,它们指向了同一部分内存,但是函数结束后,析构函数会释放这部分内存,这时候在主函数里访问这部分内存就会出现问题。

如何解决这个问题

很明显我们可以把局部对象里指针指向的那部分内存,赋给另一部分内存,并让临时无名对象的指针指向它,这样函数结束程序调用析构函数时,临时无名对象不会被修改

如何实现这个操作呢

复制构造函数,顾名思义,复制时候使用的构造函数,他只有一个参数,即对象的引用。

string a("123");
string b;
b=a;//将调用复制构造函数

如果没有定义复制构造函数,系统将自动生成一个默认的复制构造函数,它的作用是逐个复制非静态成员,复制的是成员的值,这种拷贝称为浅层拷贝,在本例中它长这个样子:

string1::string1(string1 &p)
{
   str=p.str;
}

可以看出它只是将指针指向的地址给复制了,所以就出现了上面这个问题。

要解决上面这个问题,我们需要手动定义一个复制构造函数

string1::string1(const string1 &p)
{
    len=p.len;
    str=new char[len+1];
    strcpy(str,p.str);
    cout<<"复制构造函数被调用"<<endl;
}

输出结果是

这种拷贝称为深层拷贝

何时调用复制构造函数

1.新建一个对象并将其初始化为同类现有对象时。

如果是赋值则不会调用

2.函数按值传递和返回对象时

3.作为当对象作为函数参数时

 

12.1.4赋值运算符

 

上述调用复制构造函数的时候不包括非初始化赋值的时候,也就是说当我们使用下述代码时,还是会发生浅层拷贝。

string1 a("123");
string1 b;
b = a;

可以通过重载=来实现深层拷贝

string1& string1::operator=(const string1 &p)
{
    if(this==&p)如果=两边对象地址相同,说明程序正进行自己给自己赋值这种操作,直接返回对象本身即可
    {
        return *this;
    }
    delete[] str;//要释放对象内指针本来指向的内存
    len=p.len;
    str = new char[len+1];
    strcpy(str,p.str);
    cout<<"=重载成功"<<endl;
    return *this;
}

 

返回一个对象的引用的作用是,帮助我们实现a=b=c这种操作。

12.2实现string类的其他功能

这里直接给出代码

#include <iostream>
#include <cstring>
using namespace std;
class string1
{
private:
    char *str;
    int len;
    static const int MAX=100;//最大100个字符
public:
    //构造函数
    string1();//默认构造函数
    string1(const char*);//构造函数
    string1(const string1 &p);//复制构造函数
    //重载运算符
    string1& operator =(const string1 &p);//重载=
    string1& operator =(const char *p);
    char& operator[](int i);
    //重载比较运算符
    friend bool operator <(const string1 &a,const string1 &b);
    friend bool operator >(const string1 &a,const string1 &b);
    friend bool operator ==(const string1 &a,const string1 &b);
    friend ostream& operator <<(ostream &os,const string1 &a);
    friend istream& operator >>(istream &is,string1 &a);
    //析构函数
    ~string1();//析构函数
    //其他功能函数
    int length();
    void display();
};
//构造函数
string1::string1()
{
    len=0;
    str=new char[1];
    str='\0';
}
string1::string1(const char*s)
{
    len=strlen(s);
    str = new char[len+1];
    strcpy(str,s);
}
string1::string1(const string1 &p)
{
    len=p.len;
    str=new char[len+1];
    strcpy(str,p.str);
    cout<<"复制构造函数被调用"<<endl;
}
string1& string1::operator=(const string1 &p)
{
    if(this==&p)
    {
        return *this;
    }
    delete[] str;
    len=p.len;
    str = new char[len+1];
    strcpy(str,p.str);
    cout<<"=重载成功"<<endl;
    return *this;
}
string1& string1::operator=(const char *p)
{
    delete []str;
    len=strlen(p);
    str=new char[len+1];
    strcpy(str,p);
    return *this;
}
char & string1::operator[](int i)
{
    return str[i];
}
bool operator<(const string1 &a,const string1 &b)
{
    return strcmp(a.str,b.str);
}
bool operator>(const string1 &a,const string1 &b)
{
    return b<a;//直接使用重载后的小于号
}
bool operator==(const string1 &a,const string1 &b)
{
    if(strcmp(a.str,b.str)==0)
        return true;
    return false;
}
ostream& operator <<(ostream &os,const string1 &a)
{
    os<<a.str<<endl;
    return os;
}

istream& operator >>(istream &is,string1 &a)
{
    char temp[string1::MAX];
    is.get(temp,string1::MAX);
    if(is)
    {
        a=temp;
    }
    while(is&&is.get()!='\n')
    {
        continue;
    }
    return is;
}
int string1::length()
{
    return len;
}
void string1::display()
{
    cout<<str<<endl;
}
//析构函数
string1::~string1()
{
    delete [] str;
    cout<<"析构函数被调用"<<endl;
}
int main()
{
    string1 b;
    cin>>b;
    cout<<b;
    return 0;
}

12.3在构造函数中使用new时应注意的事项

1.如果在构造函数中使用new来初始化指针成员,则应在析构函数中使用delete

2.new 和delete必须相互兼容,new对应于delete,而new[]对应于delete[]

3.如果有多个构造函数,则应该以相同的方式使用new,要么都带括号,要么都不带,因为只有一个析构函数与它兼容

4.应定义一个复制构造函数,通过深度复制将一个对象初始化为另一个对象

5.应定义一个赋值运算符,通过深度复制将一个对象复制给另一个对象

12.4有关返回对象的说明

使用const引用是为了提高效率,但对于何时采用还有一些限制。如果函数返回传递给它的对象,可以通过返回引用来提高效率

,因为返回对象会调用复制构造函数,而返回引用不会。

不能返回一个局部对象的引用,因为函数结束后,局部对象的内存会被释放,所以引用将引用一个不确定的内存。

12.5定位new运算符

 

用将定位new运算符来创建新的类对象后,当该对象消亡是时,程序并不会自动地调用其析构函数,所以必须显示地调用析构函数。这个少数的需要显示调用析构函数的情况之一。

需要注意的是,对于使用定位new运算符创建的对象,应以与创建顺序相反的顺序进行删除。原因在于,晚创建的对象可能依赖于早创建的对象。另外,仅当所有对象都被销毁后,才能释放用于储存这些对象的缓冲区。
 

 

 

【C++】C++ primer plus 第十二章--类和动态内存分配 存在可以在类中声明静态成员并初始化的情况,成员类型为const整型或者const枚举类型。 阅读详情

相关推荐

(论文速读)PTV3: 更简单、更快速、更强大的3D点云处理新突破

该论文提出PointTransformerV3(PTv3),通过简化设计实现3D点云处理的效率突破。该研究摒弃复杂注意力机制,转而采用点云序列化和补丁注意力等高效方法,将感受野从16点扩展到1024点,在保持高精度的同时实现3倍速度提升和10倍内存优化。PTv3在超过20个室内外场景任务中取得SOTA结果,ScanNet语义分割达79.4%mIoU,Waymo检测提升3.3%APH。核心创新包括四种空间填充曲线序列化模式和xCPE位置编码,为3D感知的工业应用提供了高效解决方案。

LJ1147517021的博客 1384

C++ Primer Plus 第12章:类和动态内存分配

本文介绍了动态内存分配在类中的应用,重点讲解了含有指针成员的类如何正确处理动态内存以避免浅拷贝问题。主要内容包括: 动态内存类的必要性:当类成员需要在运行时确定大小时,必须使用动态内存分配。 浅拷贝问题:默认拷贝构造函数和赋值运算符会进行浅拷贝,导致多个对象共享同一块内存,析构时引发重复释放问题。 解决方案:必须自定义拷贝构造函数和赋值运算符,实现深拷贝,为每个对象分配独立的内存空间。 实现示例:展示了完整的String类实现,包含构造函数、拷贝构造函数、析构函数、赋值运算符重载等特殊成员函数,以及静态成员

qq_40843427的博客 258

Maltab GUI课程设计——网络爬虫程序(基金连涨连跌提醒)

Maltab GUI课程设计——网络爬虫程序(基金连涨连跌提醒)

果果爱腰果的博客 851

【C++ Primer Plus】第12章 类和动态内存分配

对类成员使用动态内存分配。 隐式和显式复制构造函数。 隐式和显式重载赋值运算符。 在构造函数中使用new所必须完成的工作。 使用静态类成员。 将定位new运算符用于对象。 使用指向对象的指针。 实现队列抽象数据类型(ADT)。

chaiky的博客 1616

LaTeX伪代码字体大小调整全攻略:从algorithm到algorithm2e的实战技巧

本文详细介绍了在LaTeX中调整伪代码字体大小的全面技巧,涵盖algorithm、algorithmicx和algorithm2e等主流算法包的使用方法。从基础命令到高级配置,帮助用户解决学术论文和技术文档中的伪代码排版问题,提升算法展示的专业性和可读性。特别针对不同期刊格式要求,提供了实用的字体调整方案。

weixin_29297127的博客 439

深度学习&故障诊断初学者 - 学习路线

针对初学者,一头雾水,不知如何学习,本文给出了一个学习路线 Python学习 - 打好编程基础 https://www.bilibili.com/video/BV1vA411b7Rn?spm_id_from=333.337.search-card.all.click B站免费课程 学到P49 建议时长 2周 深度学习理论 - 浅浅理解神经网络 https://www.bilibili.com/video/BV1FT4y1E74V?p=41 建议时长 2周...............

m0_47410750的博客 6万+

《C++ Primer Plus》第12章:类和动态内存分配(1)

主要讲了复制构造函数和赋值运算符重载

weixin_40064300的博客 499

电子技术设计——16×16点阵汉字显示设计

同时,设计还应注重提升显示品质,以保证汉字的稳定展示和观感舒适。本设计的目的是构建一个能够准确在LED点阵上展示汉字的系统,并允许用户通过输入设备来选择所需的汉字,我们将验证设计方案的实际操作性和效果,以确保其满足设计目标。在LED点阵显示和汉字信息处理技术的结合下,研究者们着手研究如何在LED点阵上有效地显示汉字,并提出了一系列显示算法和优化策略,旨在实现清晰且易于阅读的汉字显示效果。首先,你需要准备16×16的LED点阵面板,通常这些点阵是8×8点阵的两倍,因此可以由两个8×8的点阵组合而成。

weixin_68094467的博客 1534

C++_primer_plus学习笔记 第12章 类和动态内存分配

对类成员使用动态内存分配 隐式和显式复制构造函数 隐式和显式重载赋值运算符 在构造函数中使用new所必须完成的工作 使用静态类成员 将定位new运算符用于对象 使用指向对象的指针 实现队列抽象数据类型......

Flying_Dutchman_的博客 629

【AI气象6】Skilful nowcasting of extreme precipitation with NowcastNet

极端降水是气象灾害的重要因素,因此迫切需要通过高分辨率、长时间预报和局部细节的精准短期预报来减轻其社会经济影响。当前的方法存在模糊、衰减、强度或位置误差,基于物理的数值方法在捕捉关键的混沌动态(如对流起始)时面临挑战,而数据驱动的学习方法则未能遵循内在的物理法则(如平流守恒)。我们提出了 NowcastNet,这是一种针对极端降水的非线性短期预报模型,将物理演变方案与条件学习方法统一到一个端到端的神经网络框架中,通过优化预测误差进行训练。基于来自美国和中国的雷达观测数据,我们的模型能够生成物理上合理的降水短

weixin_51473374的博客 2328

AI Agent开发大全第一课-AI是什么以及如何使用AI

近年来,人工智能的迅猛发展引发了广泛的关注,尤其是“大模型”这一概念越来越深入人心。大模型,顾名思义,通常指的是那些拥有大量参数、能够处理复杂任务的机器学习模型。与传统小模型相比,大模型在数据处理、信息理解和生成等方面表现更加出色。为了理解为什么现在的AI被称为大模型,我们需要深入探讨几个关键因素。立角色是指在提示词中清晰地界定交互双方的身份。明确用户希望模型扮演的角色,可以帮助模型更准确地理解上下文和用户需求。

打造全国最全的AI Agent开发知识领域的博客 1412

C++ Primer Plus 第十二章知识点(一)

C++ Primer Plus 第十二章知识点简化1. 动态内存和类 1. 动态内存和类 归纳点: 静态成员变量初始化 习惯加const        每个成

Raywit的博客 632

SAP 物料主数据 Forecasting 视图,别把预测只当成一个数字字段

摘要(150字): SAP S/4HANA物料主数据的Forecasting视图常被忽视,但对依赖历史消耗规律的物料至关重要。该功能基于工厂维度的历史消耗数据,结合预测参数自动计算未来需求,动态调整重订货点和安全库存。预测模板(Forecast Profile)能标准化参数设置,而消耗数据(Consumption Values)的质量直接影响预测结果。预测值作为MRP输入,需注意保存操作才能生效。自动重订货点功能通过分析消耗波动和服务水平,实现库存策略的动态优化。Individual Forecast功能则

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 1439

C++PrimerPlus第六版第十二章类和动态内存分配编程练习答案

1. Cow.h #ifndef Cow_H_ #define Cow_H_ #include<iostream> using std::cout; using std::endl; class Cow { private: char name[20]; char * hobby; double weight; public: Cow(); Cow(const char * ...

qq_44800780的博客 351

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

c++primer plus 6 读书笔记 第十二章 类和动态内存分配

  第十二章 类和动态内存分配 12.1 动态内存和类 动态内存分配让程序运行时决定内存分配。C++使用new和delete来动态控制内存。 12.1.1 复习示例和静态类成员 12.1.2  特殊成员函数 默认构造函数 复制构造函数(将一个对象复制到新创建的对象) 复制构造函数原型: Class_name(consr Class_name &amp;); 新建一个对象并将其初始化...

一只大鸽子的博客 474

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

C++ Primer Plus:第十二章 - 类和动态内存分配

0、本章内容: 对类成员使用动态内存分配。 隐式和显式复制构造函数。 隐式和显式重载赋值运算符。 在构造函数中使用new所必须完成的工作。 使用静态类成员。 将定位new运算符用于对象。 使用指向对象的指针。 实现队列抽象数据类型(ADT)。 1、动态内存和类: 1.1 复习示例和静态类成员 不能在类声明中初始化静态成员变量。 如果静态成员变量是const,可以在类声明中初始化。 使用new和de...

qq_30534935的博客 342

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

【C++ Primer Plus(第六版)】第十二章 类的动态内存分配

第十二章 类的动态内存分配 总结一下,这一章讲的这件事:会使用new和delete对空间的分配。 day33实现了string类例子,来完成对整个章节的总结。 12.1 动态内存和类 在类中不能确定字符串长度时,比如姓名,要定义一个指针,然后通过动态内存方式分配内存。在统计类中new的数量时,应该使用一个static静态变量,这样无论创建了多少次对象,程序只创建一个静态类变量。书中举了一个stringbad类的例子,说明了这些问题。 C++类自动提供了如下几种特殊成员函数: 默认构造函数 默认析构函数 复

weixin_43916755的博客 451

(C++Primer Plus)第十二章 类和动态内存分配笔记

12.1动态内存和类 12.1.1一些分析 #include <iostream> #ifndef STRNGBAD_H_ #define STRNGBAD_H_ class StringBad { private: char* str; int len; static int num_strings; public: StringBad(const char* s); StringBad(); ~StringBad(); frien...

margaret522的博客 382

《C++ Primer Plus》第十二章——类和动态内存分配(笔记)

的类成员,也要使用这种方法)(这是因为引用和const类似,只能在被创建时进行初始化)“假设motto是一个StringBad对象,则下面四种声明都将调用。,必须在执行到构造函数之前,即创建对象时进行初始化,可以使用。,这是因为声明描述了如何分配内存,但并不分配内存。对于使用布局new操作符创建的对象,应以与。(因为晚创建的对象可能依赖于早创建的对象。在包含类的文件中初始化,初始化时使用。中使用new(new[]),则必须在。来指出静态成员变量所属的类。,则可以在类声明中初始化”创建的,则仅当你显示使用。

2403_86782268的博客 242

C++ Primer Plus学习笔记-第十二章:类和动态内存分配

前言: 本章主要阐述对类成员使用动态内存分配的技术细节,并复习前面提到的复制构造函数,赋值运算符,静态类成员,定位new运算符,并动手实现string类; 下面这个文件提供了一个不太好的string类实现方式: #include <iostream> #ifndef STRINGBAD_H_ #define STRINGBAD_H_ class StringBad { private: char * str;//指向字符串的指针 int len;//字符串的长度 static int nu

m0_55639846的博客 331

C++ Primer Plus 第十二章答案 类和动态内存分配

复习题 ////12.9 ////1 //a, 语法是正确的,但没有将str指针初始化,应该将指针设置成NULL或使用new来初始化它 //b, 没有创建新的字符串,而只是复制了原有字符串的地址,应该使用new[]和strcpy() //c, 复制了字符串但没有分配存储空间,应该使用new char[len + 1]分配内存 // ////2 //首先,当这种类型的对象过期时,对象的成员指针指向的数据仍然保留在内存中,导致占用 //空间但是又不可访问,因为指针已经丢失。解决方法是让类的析构函数删除构造函

qq_56677326的博客 642

C++ primer plus习题及解析第十二章(类和动态内存分配)

C++ primer plus习题及解析以及我所觉得值得关注得问题。

qq_71286244的博客 389

《C++ Primer Plus 第六版》学习笔记:第十二章 类和动态内存分配

1. 静态类成员 class StringBad //在头文件中定义 { static int num_strings; //静态类成员 } int StringBad::num_strings = 0; //在方法文件中定义 注意: 静态类成员有一个特点:无论创建了多少类对象,程序都只创建一个静态类变量副本(相似的,所创建的每个新对象都有自己的存储空间,用于存储其内部变量和类成员;但同一个...

weixin_43701312的博客 409

C++Primer Plus笔记——第十二章 类和动态内存分配总结及程序清单

目录 本章小结 程序清单 改进前的string类(在构造函数和析构函数中使用了动态内存分配) 改进后的String类(添加了复制构造函数及赋值运算符) 再谈定位new运算符 复习:模拟队列 本章小结        本章介绍了定义和使用类的许多重要方面。其中的一些方面是非常微妙甚至很难理解的概念。如果其中的某些概念对于您来说过于复杂,也不用害怕——这些问题对于大多数C++的初学者来说...

YukinoAI的博客 805

C++ primer Plus(第六版)中文版 第十二章 类和动态内存分配 编程练习答案

第十二章 类和动态内存分配 1. 对于下面的声明: class Cow {     char name[20];     char * hobby;     double weight; public:     Cow();     Cow(const char * nm, const char * ho, double wt);     Cow(const Cow c&amp;);     ~...

AirHead 845

《C++ Primer Plus(第六版)》(22)(第十二章 类和动态内存分配 笔记)

1.类的静态成员,在类声明中声明,在包含类方法的文件中初始化。初始化时使用作用域运算符来指出静态成员所属的类。 如果静态成员是整形或枚举型const,则可以在类声明中初始化。 2.值传递的时候会调用复制构造函数,如果代码里面没有复制构造函数,则会生成一个系统默认的。 但是函数结束之后,就会调用析构函数。 如果是使用浅复制,可能会把原来的对象某些东西更改掉了。 构造函数的原型一般这

肥宝的实验室 2571
上一篇: python学习——类,文件和异常
下一篇: 判断是否为无损连接,保持函数依赖
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值