Question

我写了一些类将堆分配的东西移到堆栈中（希望:)）。这个calss是singleton，因为只有这个类应该负责保存和管理堆栈的一部分。我的问题是：我的代码是否正确？编程意义上的代码是正确的（没有编译错误，没有内存错误和泄漏（由valgrind检查））。但是代码真的会将堆移到堆栈中吗？这是代码：

stack.hpp：

class CStack{
public:
  void* getAlloc(long);
  static CStack* Instance();

private:
  static bool _data[5*sizeof(double)];
  static CStack* m_pInstance;

  CStack(){};
  CStack(const CStack&);
  CStack& operator=(const CStack&);
};

stack.cpp：

#include <iostream>
#include "stack.hpp"

CStack* CStack::m_pInstance = 0;

bool CStack::_data[ 5*sizeof(double) ] = { 1 };

CStack* CStack::Instance(){
  if (!m_pInstance)
    m_pInstance = new CStack;
  return m_pInstance;
}

void* CStack::getAlloc(long size){
  std::cout << "  CStack::getAlloc, " << _data << std::endl;
  _pos+=size;
  return &_data[0];
}

store.hpp

class CStore{
public:
  CStore();
  double* myAddr();
  void toStack();
  void out();
  ~CStore();
private:
  double *_data;
  bool _stack;
};

store.cpp：

#include <iostream>
#include <cstring>
#include "store.hpp"
#include "stack.hpp"

CStore::CStore(){
  _data = new double[4];
  _data[0] = 0.1;
  _data[1] = 1.1;
  _data[2] = 2.1;
  _data[3] = 3.1;
  _stack = 0;
}

double* CStore::myAddr(){ return _data; }

void CStore::toStack(){
  double *tmp;

  tmp = (double*)CStack::Instance() -> getAlloc(4*sizeof(double));

  memcpy(tmp, _data, 4*sizeof(double));
  delete [] _data;
  _data = tmp;
  _stack = 1;
}

CStore::~CStore(){
  if (!_stack)
    delete [] _data;
}

void CStore::out(){
  std::cout << _data[0] << " " << _data[1] << " " << _data[2] << " " << _data[3] << std::endl;
}

main.cpp中：

#include <iostream>

#include "stack.hpp"
#include "store.hpp"

using namespace std;

int main(){
  CStack::Instance();
  CStore a;
  double stack;

  cout << &stack << endl;
  cout << "Adresa a " << a.myAddr() << endl;
  a.out();

  a.toStack();
  cout << "Adresa a " << a.myAddr() << endl;
  a.out();

  return 0;
}

Answer 1

不，这完全是胡说八道。

首先，这段代码甚至不使用堆栈（只要我们说的是执行堆栈），你明显误解了Singleton desing模式。

当您只需要程序中的单个实例时，可以使用Singleton，但是您希望授予对该单个实例的所有函数的访问权限。它就像一个全局变量，但你可以限制访问。

其次，如果你需要在C ++中使用强制转换，如：

tmp = (double*)CStack::Instance() -> getAlloc(4*sizeof(double));

你显然出了问题。暂时不要在C ++中使用void*。你可以在以后使用它，当你变得更好，而不是现在。

主要问题为什么你要把变量移到堆栈？如果您只是想动态分配，为什么还要将其限制在范围内，请使用智能指针，如std :: auto_ptr。

如果你想创建一个堆栈，并使用它来存储你的双打，你可以写：

#include <vector>

int foo()
{
  std::vector<double> stack;

  // push values on the stack
  stack.push_back(1.1);
  stack.push_back(1.2);
  stack.push_back(1.3);

  // remove values from the stack
  stack.pop_back();
  stack.pop_back();
  stack.pop_back();
}

用于将堆移动到堆栈的Singleton类

1 个答案: