我正在尝试实现一系列转换。表示变换之前和之后的对象分别是A类和B类,用于以最小的复杂性演示该示例。换句话说,可以将类A转换为类B,将类B逆转换为类A。此外,将在类A和类B的实现中使用std :: unique_ptr的数据容器提取到类Base中。基类如下所示。
class Base
{
public:
Base() // Default constructor
{
this->size = 0;
}
~Base()
{
}
Base(int input_size, float input_value) // Constructor
{
this->size = input_size;
this->data = std::make_unique<float[]>(input_size);
for (int loop_number = 0; loop_number < size; loop_number++) {
data[loop_number] = input_value;
}
}
std::unique_ptr<float[]> get_data()
{
// deep copy
auto return_data = std::make_unique<float[]>(size);
for (int loop_number = 0; loop_number < size; loop_number++) {
return_data[loop_number] = data[loop_number];
}
return return_data;
}
int get_size()
{
return this->size;
}
protected:
int size;
std::unique_ptr<float[]> data;
};
接下来,类A和类B继承了类Base。
class B;
class A : public Base
{
public:
A(int input_size, std::unique_ptr<int[]> const& input_data) // constructor
{
std::cout << "Object A " << std::to_address(this) << " constructed.\n"; // for observation
this->size = input_size;
this->data = std::make_unique<float[]>(this->size);
for (int loop_number = 0; loop_number < input_size; loop_number++)
{
this->data[loop_number] = input_data[loop_number]; // Deep copy
}
}
A& operator=(A const& InputImage) // Copy Assign
{
this->size = InputImage.size;
for (int loop_number = 0; loop_number < this->size; loop_number++)
{
this->data[loop_number] = InputImage.data[loop_number]; // Deep copy
}
return *this;
}
~A()
{
std::cout << "Object A " << std::to_address(this) << " destructed.\n"; // for observation
}
B to_B();
private:
int transform_to_B(int input_value)
{
return std::cos(input_value); // For example
}
};
class B : public Base
{
public:
B(int input_size, std::unique_ptr<int[]> const& input_data) // constructor
{
std::cout << "Object B " << std::to_address(this) << " constructed.\n"; // for observation
this->size = input_size;
this->data = std::make_unique<float[]>(this->size);
for (int loop_number = 0; loop_number < input_size; loop_number++)
{
this->data[loop_number] = input_data[loop_number]; // Deep copy
}
}
auto to_A()
{
std::unique_ptr<int[]> transformed_data = std::make_unique<int[]>(this->size);
for (int loop_number = 0; loop_number < this->size; loop_number++) {
transformed_data[loop_number] = transform_to_A(this->data[loop_number]);
}
return A(this->size, transformed_data);
}
~B()
{
std::cout << "Object B " << std::to_address(this) << " destructed.\n"; // for observation
}
private:
int transform_to_A(int input_value)
{
return std::acos(input_value); // For example
}
};
B A::to_B()
{
std::unique_ptr<int[]> transformed_data = std::make_unique<int[]>(this->size);
for (int loop_number = 0; loop_number < this->size; loop_number++) {
transformed_data[loop_number] = transform_to_B(this->data[loop_number]);
}
return B(this->size, transformed_data);
}
主要功能是测试A类和B类的转换结果。
int main()
{
const int size_for_testing = 3840 * 2160;
auto data_for_testing = std::make_unique<int[]>(size_for_testing);
for (int loop_number = 0; loop_number < size_for_testing; loop_number++) {
data_for_testing[loop_number] = 1; // for example
}
A a_object(size_for_testing, data_for_testing);
for (int loop_times = 0; loop_times < 1000; loop_times++) // for observation
{
// version 1
a_object = a_object.to_B().to_A().to_B().to_A().to_B().to_A();
}
return 0;
}
控制台输出为
Object A 00000038FC19FE28 constructed.
Object B 00000038FC19FE10 constructed.
Object A 00000038FC19FE00 constructed.
Object B 00000038FC19FDF0 constructed.
Object A 00000038FC19FDE0 constructed.
Object B 00000038FC19FDD0 constructed.
Object A 00000038FC19FDC0 constructed.
Object A 00000038FC19FDC0 destructed.
Object B 00000038FC19FDD0 destructed.
Object A 00000038FC19FDE0 destructed.
Object B 00000038FC19FDF0 destructed.
Object A 00000038FC19FE00 destructed.
Object B 00000038FC19FE10 destructed.
Object B 00000038FC19FE10 constructed.
Object A 00000038FC19FE00 constructed.
Object B 00000038FC19FDF0 constructed.
......
我知道为处理而创建的中期对象是deallocated at the end of the scope in the for loop是有道理的。但是,如果出现更复杂的情况,例如a_object = a_object.to_B().to_A().to_B().to_A().to_B().to_A().to_B().to_A().to_B().to_A().to_B().to_A();
,则在保留这些中期对象时可能会导致大量内存消耗。我对设计“在声明范围的末尾释放对象”的概念或理念感到好奇。也许可以根据用法进行优化。
另一方面,如下所示的单独形式的内存使用与版本1类似。
// version 2
auto temp1 = a_object.to_B();
auto temp2 = temp1.to_A();
auto temp3 = temp2.to_B();
auto temp4 = temp3.to_A();
auto temp5 = temp4.to_B();
a_object = temp5.to_A();
为了尝试减少内存消耗,还考虑了以下Lambda表达式。但是,内存使用情况也与版本1类似。
// version 3
auto temp1 = [](auto& input_object) { return input_object.to_B(); }(a_object);
auto temp2 = [](auto& input_object) { return input_object.to_A(); }(temp1);
auto temp3 = [](auto& input_object) { return input_object.to_B(); }(temp2);
auto temp4 = [](auto& input_object) { return input_object.to_A(); }(temp3);
auto temp5 = [](auto& input_object) { return input_object.to_B(); }(temp4);
auto a_object = [](auto& input_object) { return input_object.to_A(); }(temp5);
顺便说一句,这种Lambda表达式似乎无法合并如下。编译器弹出C2664错误,并说“ auto main :::: operator()(_ T1&)const”:无法将参数1从“ B”转换为“ _T1&”
a_object = [](auto& input_object) { return input_object.to_A(); }(
[](auto& input_object) { return input_object.to_B(); }(
[](auto& input_object) { return input_object.to_A(); }(
[](auto& input_object) { return input_object.to_B(); }(
[](auto& input_object) { return input_object.to_A(); }(
[](auto& input_object) { return input_object.to_B(); }(a_object))))));
最后,我的问题是:
1)我很好奇设计的概念或理念“在声明对象的范围的末尾分配对象”。也许可以根据用法进行优化。
2)有没有更好的方法来减少这种级联结构的内存消耗,例如
更复杂的情况a_object = a_object.to_B().to_A().to_B().to_A().to_B().to_A().to_B().to_A().to_B().to_A().to_B().to_A();
?
环境:
CPU:Intel®Core™i7-6700HQ 2.6GHz
RAM:16GB
操作系统:Windows 10 1909
IDE:Microsoft Visual Studio Community 2019版本16.4.5
答案 0 :(得分:2)
1)我很好奇设计的概念或理念“在声明对象的范围的末尾分配对象”。也许可以根据用法进行优化。
允许临时使用该语句来“安全”。
如果可观察到的行为相同,则“假设”规则可能允许先取消分配。 由于析构函数中有输出,因此更为复杂。
2)有没有更好的方法可以减少这种级联结构的内存消耗,例如更复杂的情况a_object = a_object.to_B()。to_A()。to_B()。to_A()。to_B() .to_A()。to_B()。to_A()。to_B()。to_A()。to_B()。to_A();?
您可以为临时添加重载:
B A::to_B() &&
{
std::unique_ptr<int[]> transformed_data = std::make_unique<int[]>(this->size);
for (int loop_number = 0; loop_number < this->size; loop_number++) {
transformed_data[loop_number] = transform_to_B(this->data[loop_number]);
}
auto Bsize = this->size;
this->size = 0;
this->data.reset(); // We clear here.
// Implementation might even really transfer the buffer
return B(Bsize, std::move(transformed_data));
}