我正在研究通过向量向量实现的Matrix类，如下所示：
class Matrix {
private:
int r, c;
std::vector<std::vector<double> > grid;
public:
//things
目前，我正在实现析构函数，并对此有所考虑。在我（聪明地）切换到之前，std::vector我使用double ** grid。new因为每个指针都指向一个数组（这也是我相信的指针...或者我遇到的错误提示了...），所以这意味着要进行大量调用。无论如何，析构函数看起来像：
Matrix::~Matrix() {
for (int i = 0; i < r; i++) {
delete [] grid[i]
delete [] grid
现在，我正在尝试复制该文件（可能不必要？），并具有以下内容：
Matrix::~Matrix() {
std::vector<std::vector<double> >::iterator it = this->grid.begin();
for (it; it != this->grid.end(); it++) {
(*it).clear()
this->grid.clear();
std::vector<std::vector<double> >().swap(this->grid);
和
Matrix::~Matrix() {
this->grid.clear();
std::vector<std::vector<double> >().swap(this->grid);
我倾向于使用后者，因为它clear()应该完全破坏内部向量（而不仅仅是内部向量的内容），然后破坏临时向量的复制和交换成语作用以释放原始外部向量的内存。前者让我认为我clear()每个内部向量的内容，但是留下了n个空向量，仍在内存中，因此必须调用每个内部向量的临时交换机制（因此可能[未测试]影响我的迭代器）。
调用clear()外部向量是否会通过调用其析构函数来完全释放用于内部向量的内存？我不确定他们的析构函数是否以交换惯用法进行分配。
需要获取列表的子列表中每个索引的最小值和最大值.
如果是我的清单[[1, 2], [4, 1], [2, 2], [1, 6], [5, 3]],我会执行以下操作:
xmin = min(i[0] for i in mylist)
ymin = min(i[1] for i in mylist)
xmax = max(i[0] for i in mylist)
ymax = max(i[1] for i in mylist)
# Results:
xmin = 1
xmax = 5
ymin = 1
ymax = 6
虽然我在使用这4行时非常清楚,有没有办法在元组解压缩中获取它？
在Tkinter尝试我的手,只想添加一个简单的Text字段.我已经能够添加Entry,Button和Label而Text导致的问题.这是我有的Text:
import Tkinter
class myapp_tk(Tkinter.Tk):
def __init__(self,parent):
Tkinter.Tk.__init__(self,parent)
self.parent = parent
self.initialize()
def initialize(self):
self.grid()
self.about = Tkinter.Text(self)
self.about.insert(INSERT, "Hello World!")
self.about.grid(row=0, column=0)
if __name__ == '__main__':
myapp = myapp_tk(None)
myapp.title("My First App!")
myapp.mainloop()
收到错误:
NameError: global name 'INSERT' is not defined
我已经改变了脚本标题以包含from Tkinter import *哪个会强制它,但我很好奇为什么没有这个改变它不起作用.
不确定我的继承在这里出了问题，但我似乎只能在将子类实例存储在基类指针中时才能访问基类的方法：
class Car
{
public:
Car():type("Car") {};
Car(const char* t):type(t) {};
void get_type() const { return this->type; };
private:
std::string type;
};
class Ford : public Car
{
public:
Ford():Car("Ford"), doors(4) {};
Ford(int x):Car("Ford"), doors(x) {};
void get_doors() const { return this->doors; };
private:
int doors;
};
int main()
{
Car* c = nullptr;
c = new Ford();
c->get_doors(); // doesn't exist, only allows for get_type()
}
这很可能是指针的误用。我承认 C++ 不是我的强项，所以我试图复制一个用 Python 编写的程序，该程序大量使用继承，但它比用 C++ 编写要简单得多，因为您没有显式使用指针和引用（在抽象级别是）。
我正在探索读取格式化二进制文件的方法，并从基础开始：
>>> with open(fp, 'rb') as f:
buffer = f.read()
我的文件是 1.02GB，第一次读取它并存储在内存中需要大约 90 秒。偶然地，我不小心告诉解释器再次读取文件（按 Enter 太多次），它在 0.5 秒内读取了它。该文件在无意中重新阅读之前已关闭。
这里发生了什么？
假设我有一个琐碎的课:
class Temp {
private:
int vals;
public:
Temp():vals(0);
Temp(int x):vals(x);
Temp& someFunc(const Temp& t);
};
并说someFunc有一个条件,它将调用以下内容:
return Temp null_t; // not allowed for some reason
然而,这是有效的(正如预期的那样):
Temp null_t;
return null_t;
为什么我不能在与同一行中调用默认构造函数return？
编辑(someFunc实现):
Temp& Temp::someFunc(const Temp& rhs) {
if (this->vals == rhs.vals) {
// return a reference to an empty Temp object
*this = Temp(); // dereference, copy-assignment
return *this;
this->vals = rhs.vals
return *this
}