C++ 用于输入在一组函数中传递的参数的结构

我需要能够灵活地更改传递给不同函数的参数，这取决于函数调用发生的位置，因此我决定将所有参数放在一个结构中，但是这些参数中的大多数都是结构或类本身，我希望可以选择将其保留为空，所以我必须传递指向结构/类的指针

struct A
{
    otherB* b;  // NULL should be a valid value
    otherC* c;
};

然而，我现在的问题是，在这些指针周围传递A将是唯一被复制的东西，所以如果我做了以下操作，就会有问题，对吗

void func(A& a) //non const cause I wanna change contents of A.
{
   a.b = new b();
}

A myA;
otherC somec; // all these are currently automatic variables in my pgm.
myA.c = &somec;

func(myA);  //myA goes out of scope? so I've lost all pointers assigned and since somec is out of scope too, I have a problem?

解决这类问题的最佳方法是什么？+我希望能够灵活地将NULL传递给我的任何参数，但不确定是否到处使用原始指针是个好主意？

boost:：optional

允许您测试字段是否已设置

简单的例子（不会编译，我甚至没有远程测试过，理论上这就是它应该如何工作的）

struct参数
{
boost：：可选a；
boost：：可选b；
boost：：可选c；
};
无效函数（参数S&p）
{
如果（每年）
{
//用手指做东西
}
如果（临b）
{
//和b一起做事
}
如果（p.c）
{ 
//用c做东西
}
其他的
p、 c=bar（）；//再次复制已构造且现在已初始化。。。
}
参数p；
p、 a=1；
p、 b=foo（）；//复制构造，但是也可以将引用存储在可选文件中。
//c是未初始化的
func（p）；
//当p超出范围时，一切都消失了。。

boost:：optional

允许您测试字段是否已设置

简单的例子（不会编译，我甚至没有远程测试过，理论上这就是它应该如何工作的）

struct参数
{
boost：：可选a；
boost：：可选b；
boost：：可选c；
};
无效函数（参数S&p）
{
如果（每年）
{
//用手指做东西
}
如果（临b）
{
//和b一起做事
}
如果（p.c）
{ 
//用c做东西
}
其他的
p、 c=bar（）；//再次复制已构造且现在已初始化。。。
}
参数p；
p、 a=1；
p、 b=foo（）；//复制构造，但是也可以将引用存储在可选文件中。
//c是未初始化的
func（p）；
//当p超出范围时，一切都消失了。。

要解决资源管理问题，您应该使用C++0x中的

boost:：shared_ptr

（或

std:：shared_ptr

）

---

这不会删除对象，它不会做任何事情（这正是我们想要的堆栈分配对象）。但是请记住，您必须确保

somec

的寿命长于

myA

，否则您将遇到访问冲突。

要解决资源管理问题，您应该使用

boost:：shared_ptr

（或

std:：shared_ptr

在C++0x中）

---

这不会删除对象，它不会做任何事情（这正是我们想要的堆栈分配对象）。但是请记住，您必须确保

somec

的寿命长于

myA

，否则您将遇到访问冲突。

您基本上必须分析所有权，即谁可以分配对象，谁负责在对象不再使用时删除对象

需要记住的一点是，如果您将动态分配的内容和放置在堆栈上的内容混合在一起，您就不能对它们应用

delete

，因为不可能删除堆栈上的内容

---

一种方法是只使用

new

并在

a

中定义一个析构函数，删除它的所有指针。另一种方法是注册以后应该删除的对象。或者您可以按照其他答案中的建议，使用现有的引用计数工具。

您基本上必须分析所有权，即谁可以分配对象，谁负责在对象不再使用时删除对象

需要记住的一点是，如果您将动态分配的内容和放置在堆栈上的内容混合在一起，您就不能对它们应用

delete

，因为不可能删除堆栈上的内容

---

一种方法是只使用

new

并在

a

中定义一个析构函数，删除它的所有指针。另一种方法是注册以后应该删除的对象。或者你可以按照其他答案中的建议，使用现有的参考计数工具。

不，你对

myA

和

somec

范围的想法是错误的。你现在所拥有的并没有错——尽管我个人认为引用比指针更好

void func(A& a) //non const cause I wanna change contents of A.
{
    a.b = new b();
}


int main() {
    A myA;
    otherC somec; // all these are currently automatic variables in my pgm.
    myA.c = &somec;

    func(myA);
    // myA and somec are still perfectly in scope to be saved, or deleted, or w/e as you like
}

---

不，您对

myA

和

somec

范围的想法是错误的。你现在所拥有的并没有错——尽管我个人认为引用比指针更好

void func(A& a) //non const cause I wanna change contents of A.
{
    a.b = new b();
}


int main() {
    A myA;
    otherC somec; // all these are currently automatic variables in my pgm.
    myA.c = &somec;

    func(myA);
    // myA and somec are still perfectly in scope to be saved, or deleted, or w/e as you like
}

---

你的描述不清楚，但如果你有问题 因为somec超出了范围，所以只能因为func是 保存指针的副本。不要这样做：在funct中，复制对象， 不是指针

PS：如果大多数指针在大多数时候都是空的，那么您应该 考虑使用下列类似的句法糖：

struct A
{
    //  pointer members...
    A() : // ... set all pointers to null...
    A& withB( B const& someB ) { otherB = &someB; return *this ; }
    A& withC( C const& someC ) { otherC = &someC; return *this ; }
    //  And so on for all of the rest of the pointers.
};

func( A().withC( somec ) );

不知道这是否适合你的情况，但通常

---

方便。

从您的描述中不清楚，但如果您遇到问题 因为somec超出了范围，所以只能因为func是 保存指针的副本。不要这样做：在funct中，复制对象， 不是指针

PS：如果大多数指针在大多数时候都是空的，那么您应该 考虑使用下列类似的句法糖：

struct A
{
    //  pointer members...
    A() : // ... set all pointers to null...
    A& withB( B const& someB ) { otherB = &someB; return *this ; }
    A& withC( C const& someC ) { otherC = &someC; return *this ; }
    //  And so on for all of the rest of the pointers.
};

func( A().withC( somec ) );

不知道这是否适合你的情况，但通常

---

方便。

它可以防止

共享\u ptr

尝试删除堆栈分配的对象，这将导致灾难。但是，如果您正在使用堆栈上的对象，共享\u ptr的出发点是什么？如果有别的事情可以做

struct A
{
    //  pointer members...
    A() : // ... set all pointers to null...
    A& withB( B const& someB ) { otherB = &someB; return *this ; }
    A& withC( C const& someC ) { otherC = &someC; return *this ; }
    //  And so on for all of the rest of the pointers.
};

func( A().withC( somec ) );