在c++中使用智能指针在成员函数中构造的嵌套类
在C++中，智能指针是一种管理动态分配内存的工具，它可以帮助程序员避免内存泄漏。智能指针主要有std::unique_ptr、std::shared_ptr和std::weak_ptr等类型。在成员函数中构造嵌套类时，智能指针的使用需要特别注意对象的生命周期管理。
基础概念
嵌套类（Nested Class）是定义在另一个类内部的类。嵌套类可以访问其外部类的私有和保护成员。智能指针在嵌套类中的使用，主要是为了管理嵌套类对象的生命周期。
相关优势
使用智能指针管理嵌套类对象的优势包括：
- 自动内存管理：智能指针可以自动释放不再使用的对象，防止内存泄漏。
- 异常安全：即使在发生异常的情况下，智能指针也能确保资源被正确释放。
- 简化代码：减少了手动管理内存的复杂性，使代码更加简洁和易于维护。
类型与应用场景
std::unique_ptr
std::unique_ptr是一种独占所有权的智能指针，它保证同一时间只有一个unique_ptr可以指向该对象。
应用场景：当你需要确保一个对象只有一个所有者时，可以使用std::unique_ptr。
class OuterClass {
public:
class NestedClass {
public:
NestedClass() { /* ... */ }
~NestedClass() { /* ... */ }
};
std::unique_ptr<NestedClass> createNestedObject() {
return std::make_unique<NestedClass>();
}
};std::shared_ptr
std::shared_ptr是一种共享所有权的智能指针，允许多个shared_ptr共享同一个对象的所有权。
应用场景：当你需要多个对象共享同一个资源时，可以使用std::shared_ptr。
class OuterClass {
public:
class NestedClass {
public:
Nested类() { /* ... */ }
~Nested类() { /* ... */ }
};
std::shared_ptr<NestedClass> createNestedObject() {
return std::make_shared<NestedClass>();
}
};std::weak_ptr
std::weak_ptr是一种弱引用的智能指针，它指向一个由std::shared_ptr管理的对象，但不会增加对象的引用计数。
应用场景：当你需要避免循环引用导致的内存泄漏时，可以使用std::weak_ptr。
class OuterClass {
public:
class NestedClass {
public:
NestedClass() { /* ... */ }
~NestedClass() { /* ... */ }
};
std::shared_ptr<NestedClass> createNestedObject() {
auto shared = std::make_shared<NestedClass>();
std::weak_ptr<NestedClass> weak = shared;
// 使用weak指针时需要检查是否有效
if (auto locked = weak.lock()) {
// 使用locked指向的对象
}
return shared;
}
};遇到的问题及解决方法
问题：在成员函数中构造嵌套类对象时，智能指针无法正确管理对象的生命周期。
原因：在成员函数中构造的嵌套类对象可能会在函数返回后被销毁，导致智能指针指向无效的内存。
解决方法：确保智能指针在函数返回后仍然有效。可以使用std::make_unique或std::make_shared来创建智能指针，这样可以确保对象的生命周期得到正确管理。
class OuterClass {
public:
class NestedClass {
public:
NestedClass() { /* ... */ }
~NestedClass() { /* ... */ }
};
std::unique_ptr<NestedClass> createNestedObject() {
// 使用std::make_unique确保对象的生命周期得到正确管理
return std::make_unique<NestedClass>();
}
};参考链接
- std::unique_ptr - cppreference.com
- std::shared_ptr - cppreference.com
- std::weak_ptr - cppreference.com
通过以上内容，你应该能够理解在C++中使用智能指针在成员函数中构造嵌套类的基础概念、优势、类型、应用场景以及常见问题的解决方法。
相关·内容
2回答
我有一个很简单的问题。我正在努力学习C++，我遇到了一个小问题。这是密码
system.h
#include <iostream>
#include "processor.h"
using namespace std;
class sys
{
public:
int id;
sys()
{
id=0;
}
};
processor.h
#include <iostream>
using namespace std;
class proc
{
publ
浏览 4提问于2013-09-22得票数 0
回答已采纳
2回答
我使用C++作为应用程序主干，使用Objective-C作为图形用户界面，这很好。
但是当涉及到在Objective-C++ (.mm文件)中混合这些代码时，我有几个问题：
1.我可以将STL容器与Objective-C或Cocos2D对象混合使用吗？
例如，在Objective-C头文件中，我可以执行以下操作吗？
#include <vector>
#include <boost\shared_ptr.hpp>
@interface MyClass : NSObject {
std::vector<boost::shared_ptr<CCSprite&
浏览 5提问于2011-11-18得票数 11
回答已采纳
2回答
我在C++和嵌套类方面遇到了一些问题。例如：
在main.cpp中
int main()
{
B b(par);
cout << b.Aglobal->parametro;
cout << b.Aglobal->parametro;
return 0;}
在B.cpp中
B: B(type par)
{
A a(par1,par2);
Aglobal=&a;}
在B.h .
class B
{
public:
B(type);
A *Aglobal;}
在A.h .
class A
{
public:
A(type1,t
浏览 0提问于2012-05-20得票数 1
回答已采纳
4回答
这个问题是基于Scott在他的书“更有效的C++”中提供的一个例子。请考虑以下课程：
// A class to represent the profile of a user in a dating site for animal lovers.
class AnimalLoverProfile
{
public:
AnimalLoverProfile(const string& name,
const string& profilePictureFileName = "",
浏览 1提问于2018-01-16得票数 1
回答已采纳
有一天，我在面试中遇到了这个问题。所以只要引导我就好。
如果c++中的构造函数抛出异常，如何清理初始化的资源？
浏览 2提问于2012-10-04得票数 7
回答已采纳
3回答
我正在学习C++中的RAII成语，以及如何使用智能指针。
在我的阅读中，我遇到了两件事，在我看来，这两件事似乎相互矛盾。
引用自
...if是一个具有RAII语义的成员对象，在构造函数完成之前就会发生异常，然后将调用它的析构函数作为堆栈展开的一部分。因此，一个控制多个资源的对象可以保护它们的清理，即使它不是通过使用成员RAII对象完全构建的。
但是引用了
如果构造函数抛出异常，则不运行对象的析构函数。如果您的对象已经做了一些需要撤消的事情(例如分配一些内存、打开一个文件或锁定一个信号量)，这个“需要撤消的东西”必须被对象内的一个数据成员记住。
然后，第二个链接源建议使用智能指针来处理构造
浏览 4提问于2012-02-03得票数 20
回答已采纳
假设我有一个公共类和一个私有实现类(例如，PIMPL模式)，我希望用一个带有选中delete的模板智能指针类包装私有类，如下所示：
PublicClass.h
class PrivateClass;
// simple smart pointer with checked delete
template<class X> class demo_ptr
{
public:
demo_ptr (X* p) : the_p(p) { }
~demo_ptr () {
// from boost::checked_delete: don't all
浏览 4提问于2013-04-09得票数 3
回答已采纳
2回答
数组中的资源泄漏
、、、
我有以下类：
class estimate
{
public:
estimate();
~estimate();
double *tHanning;
}
estimate::estimate()
{
tHanning = NULL;
tHanning = new double [1000];
for (int m=0; m<1000; m++)
{
tHanning[m]=(0.5-0.5*cos(2.0*PI*(m+1)/(1001)));
}
}
estimate:
浏览 0提问于2013-07-29得票数 2
2回答
我在Objective-C类中声明了一个C++对象。
C++对象只有一个接受多个参数的构造函数。
在C++代码中，我会在包含构造函数的类的初始化列表中解析构造函数的参数。
我如何在Objective-C中做同样的事情？
当我编译时，我得到一个错误，告诉我C++对象没有合适的默认构造函数，正如您所期望的那样。
浏览 0提问于2012-07-18得票数 2
回答已采纳
我主要是一个c#程序员，但我正在从事的一个项目让我使用c++。在C#中，我能够定义一个类的成员，其中的成员是空的，直到它被初始化。就像这样：
Class Foo{
private Bar _bar;
public Foo(int valueBarNeeds){
_bar = new Bar(valueBarNeeds);
}
}
_bar的值为null，在初始化之前禁止访问。这个用例的基本原理是，私有对象的构造函数依赖于直到父类被构造后才知道的某个值。
现在，在C++中，我尝试做同样的事情：
class Foo{
public:
Foo(int
浏览 2提问于2013-11-10得票数 9
回答已采纳
2回答
我正在从Java迁移到C++，我真的很喜欢它。我不喜欢的一件事是根本不理解内存，因为Java曾经为我做过这件事。
我买了一本书: Memory as a Programming Concept in C and C++ - Frantisek Franek
有没有一些好的站点可以让我去交互式地学习C/C++和内存的使用(教程、论坛、用户组)？
浏览 0提问于2010-02-10得票数 6
回答已采纳
3回答
.的复制
在C++中，有时您必须自己实现复制构造函数(当您将指针作为成员时)。在编译器生成的复制构造函数中，这有一个缺点，即当您添加一个成员字段而忘记在复制构造函数中添加复制行时，您会遇到一个问题，这个问题通常很难跟踪。我喜欢防守，这让我有点担心。
一种解决方案是使用memcpy，然后正确地处理指针，但据我所知，这是不鼓励的。
浏览 0提问于2009-03-27得票数 0
是否有可能在C++中自动生成析构函数？
这是一个很大的负担，不能一直靠自己去做。编译器是否很难生成析构函数？它不能检测什么是“资源”并在析构函数中释放它吗？
浏览 9提问于2014-01-09得票数 10
回答已采纳
4回答
在参数化构造函数的C++中，我有一些理解问题。如果我有一个具有两个函数参数的构造函数的类，如何在另一个类头文件中实例化它？
例如：
public:
MyFunction myfunction(param1, param2); //makes an error
我如何声明这样的对象？
浏览 8提问于2016-03-31得票数 0
回答已采纳
4回答
在Java中，您可以将接口定义为没有实际代码实现的类，而只是定义类必须实现的方法。这些类型可以作为参数传递给方法，并从方法返回。在C++中，据我所知，纯虚拟类不能用作参数或返回类型。有没有办法模仿Java的接口类？
我在C++中有一个string类，以及从基本string类派生的几个子类，用于不同的编码(如UTFxxx、ISOxxx等)。但是，由于有这么多不同的编码，基类没有有意义的实现。但是，如果我可以将它作为自己的对象来处理，并且对该对象的调用将调用它继承到的正确的子类，那么它就可以很好地作为一个接口。
浏览 2提问于2011-11-20得票数 2
回答已采纳
4回答
我是一个c++初学者，现在正在阅读C++入门。关于破坏者我有一些问题：
在第13.1.3章中说：“在析构函数中，没有什么类似于构造函数初始化程序列表来控制成员被销毁的方式；销毁部分是隐含的。当成员被销毁时会发生什么情况取决于成员的类型。类类型的成员是通过运行成员自己的析构函数来销毁的。内置类型的没有析构函数，所以不对内置的类型的成员进行破坏。”
所以如果我有这样一个类：
class Foo {
~Foo() { delete pi; }
int *pi;
int i;
};
当要销毁Foo实例时，根据上面的文本，内置类型变量int i将不会被销毁？那么它将如何存在，因为它所属的对
浏览 7提问于2022-02-06得票数 4
回答已采纳
2回答
假设我有一个设备类。我不希望程序员能够实例化他自己的设备对象，所以现在我创建了一个DeviceManager类。DeviceManager是唯一将被实例化的实体，并且通过让程序员指定某种类型的ID来向程序员提供对设备对象的访问。这样，程序员只需要清理DeviceManager类，就不会留下任何零散的设备对象。我主要关心的是如何控制对对象的访问，以便进行深入的垃圾收集。像我在C++中描述的“管理器”模式是一个好主意吗？谢谢!
浏览 0提问于2012-03-16得票数 0
回答已采纳
4回答
我是C++的新手。据我所知，与java不同，C++没有自动垃圾处理功能，因此我们在类中为对象添加了析构函数：
class A{
class A();
~class A(); // destructor
};
我很好奇当我们使用structs时会发生什么。另外，当我们不向类添加析构函数时会发生什么？内存是如何释放的？
浏览 0提问于2013-03-10得票数 1
2回答
我正在将C代码转换为C++。
有矩阵指针：
MATRIX* matrix = NULL;
matrix = new MATRIX[256];
if (matrix == NULL)
return FAIL;
memset(matrix, 0, 256*sizeof(MATRIX));
然后用另一种方法填充：
fillUpMatrix(matrix);
在fillUpMatrix()中：
memcpy(&matrix[start], &someOtherMatrix[pos], sizeof(MATRIX));
稍后，memset被调用为指针，因为它将被填充一组不同的值：
浏览 0提问于2019-06-26得票数 6
回答已采纳
我正在使用iPhone应用程序中的C++音频库。有没有什么Objective C/ Cocoa内存管理基础设施可以用于我的C++对象，或者我只需要阅读并学习C++内存管理？
浏览 2提问于2010-03-12得票数 3
回答已采纳
2回答
我遇到了下面部分显示的这个模板化的智能指针类Cptr，我不理解其中的一个方法实现，并且希望得到一些输入。我的问题是“方法2”，标签如下。具体来说，如果Cptr是由T模板化的，那么可以使用什么调用语法来调用'Method 2‘，这至少在我看来是一个复制构造函数，但我认为复制构造函数没有模板化。
template <class T> class Cptr
{
public:
/* Constructors ... */
/* Getters ... */
T* ptr() const { return p_; }
浏览 3提问于2017-01-31得票数 0
回答已采纳
在一个充满对象(具有适当行为)和相对较少的非面向对象结构(仅由数据字段和没有方法组成)的C++项目中，我希望防止这些结构的意外误用，在这些结构中，您可能会尝试创建继承它的类。
根据我的理解，由于这些" POD“(普通旧数据)结构没有虚拟析构函数，因此不可能通过POD类型的指针正确删除派生类对象(如果允许创建的话)。
这似乎为C++11 "final“关键字提供了一个很好的用例，该关键字将类或结构标记为不可继承。
然而，我不知道“最终”关键字是否会导致结构变成非POD？
我怀疑标准文档可能已经解决了这个问题，但我没有足够的智慧来筛选非常长的文档来找出答案。欢迎提供任何有用的指示。
浏览 2提问于2015-07-14得票数 7
回答已采纳
3回答
我正在阅读Stroustrup的C++编程书中的一段代码。
class Vector_container : public Container {
Vector v;
public:
// Vector_container implements Container
Vector_container(int s) : v(s) { } // Vector of s elements
~Vector_container() {}
double& operator[](int i) { return v[i]; }
int size(
浏览 0提问于2019-07-10得票数 2
回答已采纳
6回答
请考虑这样一个纯虚拟类：
class Foo {
public: virtual int FooBar() = 0;
};
Java开发人员会称之为“接口”。通常，您然后编程到该接口，例如(糟糕的示例，对不起)：
class Bar {
public: Foo f;
};
class Child : public Foo {
public: int FooBar() { return 1; }
};
Bar b;
b.foo = Child();
这在C++中显然不起作用，因为类Foo的实例是在构造时创建的(但这是不可能的，因为Foo是一个抽象类)。
在C++中有“
浏览 0提问于2012-08-14得票数 1
回答已采纳
也许我所要求的只是一个我还没有找到的网站的链接。但是来自Java背景，在C++中处理内存分配和删除的一般指导原则是什么？我觉得我可能会在我的应用程序中添加各种内存泄漏。我知道有几种不同的智能指针，您也可以在我这里提及它们，但我想重点介绍标准的C++指针。
浏览 0提问于2010-07-20得票数 4
回答已采纳
3回答
所以我的想法很简单--一个类可以有自己的公共方法，一个嵌套的类只转发一些公共方法(伪代码)：
class API
{
public:
go();
stop();
friend class B
{
public:
void public_request()
{
request();
}
void public_go()
{
go()
}
};
private:
void request(){}
};
浏览 0提问于2011-07-25得票数 0
回答已采纳
当我开始采用更多的boost成语时，我很好奇，什么似乎是最佳实践?我想知道，我的c++在什么时候看起来甚至有点像去年的c++，在典型例子中经常出现，在那些没有接触过“现代C++”的人的脑海中也经常出现？
浏览 2提问于2008-12-12得票数 12
回答已采纳
4回答
我是c++的初学者，所以很多事情在我的脑海中都不太清楚。
我需要编写这段代码，在一个类中我创建了一个构造函数。但是，我不需要任何参数，因为我从构造函数内部的文件流中读取.所以我的问题是：
1.我是否可以这样做一个构造函数：
class myClass {
private:
string title;
string organizer;
public:
myClass() {
title = stringRead();
organizer = stringRead();
}
}
stringRead()是我写的从文件中读取的函数吗？？
2.当我需要它时，我该如何称
浏览 8提问于2015-06-06得票数 2
回答已采纳
6回答
动态类成员与非动态类成员
、、、
在C++中，ff我有一个类，它需要保存一个成员，这个成员可以动态分配并用作指针，也可以不使用，如下所示：
class A {
type a;
};
或
class A {
A();
~A();
type* a;
};
在构造函数中：
A::A {
a = new type();
}
和析构函数：
A::~A {
delete a;
}
除了需要更多代码的动态代码外，这两种方法都有什么优点或缺点？它们的行为是不同的(除了指针必须被解除引用)，还是一个比另一个慢？我应该使用哪一个？
浏览 0提问于2010-07-27得票数 5
3回答
通过智能指针分配给类成员
、、、、
我对C++还是很陌生的，当我探索智能指针时，有一种行为我无法完全理解。
考虑以下简单的类：
class Student {
public:
int studentID;
string gender;
string name;
Student(int studentID, string gender, string name)
{
this->studentID = studentID;
this->gender = std::move(gender);
this->name = std
浏览 1提问于2018-03-23得票数 2
回答已采纳
在C++中，如何在该类的成员函数中打印该类对象的地址？
class A
{
int x;
private:
A(){x=2;}
}
int main()
{
A B;
return 0;
}
如何在成员函数或main()中打印B的地址。
浏览 3提问于2013-12-26得票数 6
请列出复制构造函数和赋值运算符在C++中需要完成的任务，以保持异常安全，避免内存泄漏等。
浏览 1提问于2008-10-18得票数 18
回答已采纳
我正在为一个类创建一个接口包装器。类中的成员是一个引用(以避免复制大型结构)。如果我创建了一个私有构造函数，那么初始化该引用以安抚编译器的最佳方式是什么？
struct InterfaceWrapper {
InterfaceWrapper( SomeHugeStructure& src ):m_internal(src){};
int someElement(void) const { return m_internal.someElement; };
private:
InterfaceWrapper(){} // initialize m_interna
浏览 1提问于2008-11-12得票数 3
回答已采纳
我真不敢相信我找不到明确的答案.
在使用C++运算符初始化异常的情况下，如何释放在new类构造函数抛出异常后分配的内存。例如：
class Blah
{
public:
Blah()
{
throw "oops";
}
};
void main()
{
Blah* b = NULL;
try
{
b = new Blah();
}
catch (...)
{
// What now?
}
}
当我尝试这样做时，b在catch块中为NULL (这是有意义的)。
调试时，我注意到控制在访问构造函数之前进入内存分配例程
浏览 2提问于2009-11-04得票数 54
回答已采纳
8回答
我感到困惑的是：
返回对象(但随后从函数中的局部变量复制对象，这将消耗内存)
返回一个指针(但是您必须记住在调用代码中删除它，这很奇怪)
返回引用(但这是不可能的，因为这将是对函数局部变量的引用，一旦函数结束，该变量将被删除)
我正在寻找从C++函数返回对象的正确方法，在基本C++中(没有库处理指针和自动释放内存)。我想知道该怎么做。
谢谢
浏览 0提问于2010-10-17得票数 4
回答已采纳
我想知道如果我的类中有一个A*成员，如果我在下面的形式中有我的类的构造函数，我们是否应该自动设置为nullptr：
class MyCLass
{
A* m_pointer;
public:
MyCLass()
{
}
};
我在C++11中使用MyCLass* o = new MyCLass;还是MyCLass* o = new MyCLass();，这有关系吗？
浏览 0提问于2014-10-01得票数 9
回答已采纳
3回答
我有一个对象，它包含一个抽象类实例的列表。
class A { }; // abstract class
class B {
public:
void addA(const A& a) {
list_of_a_.push_back(&a);
}
private:
std::vector<const A*> list_of_a_;
};
A是抽象的，所以我将它们作为指针存储在向量中，并将其作为const引用传递。我有不同的A子类。
然后我有一个类似工厂的函数，它创建B并返回它。
B CreateB() {
B b;
Derivati
浏览 0提问于2017-02-11得票数 0
回答已采纳
我正在学习C++，但我不清楚类的析构函数。例如：
class A:
{
public:
int valueA;
private:
int valueB;
};
A:~A()
{
delete valueA;
delete valueB;
}
那么，从根本上说，删除所有公开和私有的声明是正确的吗？
浏览 0提问于2010-12-01得票数 0
回答已采纳
3回答
智能指针和复制构造函数
、、、、
根据我的理解，提供用户定义的复制构造函数的主要原因是，我们需要确保数据成员指针是深度复制的。
这是否意味着如果我们用智能指针替换原始指针数据成员，那么提供用户定义的副本构造函数的频率就会降低吗？
浏览 9提问于2014-04-01得票数 0
1回答
对于C++来说，这是个很新的问题，所以这可能是一个非常愚蠢的问题。我需要cube_normals指针被成员函数read_models()和proc_models()访问，每次调用read_models()时都必须初始化指针。
在成员函数中，我可以这样做：
PointCloud<A>::Ptr cube_normals (new PointCloud<A>);
我可以将指针传递给另一个函数，但是我正在使用12个这样的指针，这可能不是解决这个问题的最干净的方法。
这是代码片段。提前感谢！
class preproc
{
public:
preproc();
浏览 5提问于2016-11-12得票数 4
回答已采纳
有人告诉我构造函数会创建对象。但在互联网上，我搜索对象创建时执行的构造函数。你能解释一下吗？我是C++的新手
浏览 4提问于2015-05-09得票数 3
回答已采纳
从C++中的思考
构造函数的第一个隐藏参数是这个指针。此指针保存调用方对象的地址。在构造函数的情况下，此指针指向未初始化的内存块。构造函数的任务是正确地初始化这个内存块.
因此，基本上，构造函数被用来获取指向RAM中对象空间的指针？对吗？
默认构造函数如何初始化该内存？它是否被初始化为零？
浏览 10提问于2013-09-12得票数 1
在学习C++ (和Direct3D，但那是在一段时间以前)的时候，有一件事让我感到困惑，那就是什么时候应该在类中使用指针成员。例如，我可以使用非指针声明：
private:
SomeClass instance_;
或者我可以使用指针声明
private:
Someclass * instance_
然后在构造函数中对它使用new()。
我知道如果SomeClass可以派生自另一个类，一个COM对象，或者是一个ABC，那么它就应该是一个指针。有没有其他我应该注意的指南？
浏览 1提问于2009-07-24得票数 27
回答已采纳
根据c++规则，在定义派生类对象时，先调用基类构造函数初始化基类成员，然后再初始化派生类构造函数。对于析构函数，规则将恢复。
我想知道为什么要遵守这个规则。为什么先是基类构造函数，然后是派生类构造函数？有什么理由要这样做吗？或者仅仅因为它是c++的定义。
谢谢,
浏览 16提问于2013-02-13得票数 5
6回答
这可能是一个主观的问题，但我或多或少地问它，并希望人们分享他们的经验。(因为这是我在C++中最缺乏的东西)
无论如何，假设我有一些不清楚的原因--一个初始化函数，它从堆中初始化数据结构：
void initialize() {
initialized = true;
pointer = new T;
}
现在，当我两次调用初始化函数时，就会发生内存泄漏(对吗？)。所以我可以防止这是多种方法：
忽略调用(检查是否初始化了我，如果我什么都不做)
抛出错误
自动“清理”代码，然后重新初始化。
现在，什么通常是“最佳”方法，这有助于保持我的代码在未来的可维护性？
编
浏览 4提问于2010-11-18得票数 2
5回答
，我想知道，对于必须具有相对较大范围/较长生存期的对象，进行对象初始化和存储的最佳方法是什么。假设我们有一个GameEngine类，它需要初始化并保存对Window的引用来进行呈现。在整个程序的生命周期中都需要引用，并且窗口至少需要知道它的尺寸。
在Java中，我会这样做：
// Declaration:
Window window;
// Initialization:
window = new Window(width, height);
我了解到，在initialization.中，第一个已经调用了窗口类的默认构造函数，因此是声明和因此，拥有一个window = Window(width
浏览 6提问于2015-06-03得票数 8
回答已采纳
4回答
这很可能是一个极端的新手问题，但我不太理解。这可能是非常简单的事情，但我对c++没有太多的经验，我正在努力学习。
我试着用我想要理解的东西的简化版本来解释它。
我有一个叫Foo的类。它的构造函数有两个参数。
我有一个名为Bob的类，在这个类中我想要一个Foo的私有实例，但是直到我进入Bob的构造函数时，我才知道要传递给foo构造函数的参数。
class Foo
{
public:
Foo(int a, int b);
~Foo();
int getA();
int getB();
};
class Bob
{
public:
Bob();
~B
浏览 4提问于2015-12-17得票数 0
2回答
嘿，伙计们，我想知道控制台在C++的简单代码中会显示什么
using namespace std;
class Tier {
public:
string name;
};
int main()
{
Tier Affe;
cout << Affe.name << endl;
}
我来自C#，并且知道会抛出一个"null"-Error。但在C++中，控制台没有显示任何内容。调试时，属性为"“。
这是否意味着属性"name“引用了一个空指针？考虑到从类"Tier“创建对象，就会分配具有类大小的内存。因此，对
浏览 2提问于2016-01-13得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
