相关疑难解决方法(0)

我正在浏览一些代码,计划将其用于我的研究.所以头文件看起来像这样

#ifndef SPECTRALCLUSTERING_H_
#define SPECTRALCLUSTERING_H_

#include <vector>
#include <eigen3/Eigen/Core>

class SpectralClustering {
public:
    SpectralClustering(Eigen::MatrixXd& data, int numDims);
    virtual ~SpectralClustering();

    std::vector<std::vector<int> > clusterRotate();
    std::vector<std::vector<int> > clusterKmeans(int numClusters);
    int getNumClusters();

protected:
    int mNumDims;
    Eigen::MatrixXd mEigenVectors;
    int mNumClusters;
};

#endif /* SPECTRALCLUSTERING_H_ */

后者在主代码中

#include "SpectralClustering.h"
#include <eigen3/Eigen/QR>

SpectralClustering::SpectralClustering(Eigen::MatrixXd& data, int numDims):
    mNumDims(numDims),
    mNumClusters(0)

所以我不明白为什么在.h文件中使用虚拟析构函数.从这个我们可以得知,虚析构函数是有用时,你可以通过指针删除派生类的实例,立足class.But我想,这是不是跟这个code.Can有人区分解释这一切？

这是我试图理解输出的代码.

class A
    {
    public:

        A();
        ~A(){ cout<<"Destructor Called from A"<<endl;}
        A(int x):Z(x){ cout<<"Constructor Called from A"<<endl; };

    private:
        int Z;
    };

    class B:public A
    {
    public:

        B();
        ~B(){ cout<<"Destructor Called from B"<<endl;}
        B(int x):A(x),Y(x){ cout<<"Constructor Called from B"<<endl; };

    private:
        int Y;
    };

    int main() {

        A *a = new B(10);        
        delete a;

        return 0;
    }

为此,我得到了输出

Constructor Called from A
Constructor Called from B
Destructor Called from A

我的问题是,类的析构函数发生了什么B？对象切片是否在这里起作用？

当我用c ++ 11和发布模式练习clang ++中的多态时,我得到了2个'对vtable的未定义引用'的错误.以下是我的代码的一些部分.

#include <armadillo>
typedef float CHOSENONE;
typedef std::vector<std::vector<CHOSENONE> > fVect2d;
typedef std::vector<CHOSENONE> fVect;
class CfSubSet {
    private:
        fmat m_Data;
        frowvec m_Label;
        int m_NumInstances, m_NumFeatures ;
    public:
        CfSubSet(){
            cout<<"hello! \n" <<endl;
            m_NumInstances = 0;
            m_NumFeatures = 0;
            m_Data.zeros();
            m_Label.zeros();
        }
        CfSubSet(int iNumInstances, int iNumFeatures):m_NumInstances(iNumInstances),m_NumFeatures(iNumFeatures){
            m_Data.resize(iNumInstances,iNumFeatures);
            m_Label.resize(iNumInstances);
        }
        ~CfSubSet(){
            m_Data.reset();
            m_Label.reset();
        }
        inline int getNumInstances(){return m_NumInstances;};
        inline int getNumFeatures(){return m_NumFeatures;};
        inline fmat& getData(){return m_Data;};
        inline fmat& getLabel(){return m_Label;};
};

class CData
{
    protected:
        CfSubSet * m_Test;
        CfSubSet * m_Train; …

#include <iostream>
#include <string>
using namespace std;

class Part{
public:
    std::string spec;
    Part(std::string str){
        this->spec = str;
    }
    std::string getSpec(){
        return spec;
    }
};

class Car{
public:
    Part getEngine();
    Part getWheels();
    Part getBody();
};


class Benz:public Car{
public:
    Part getEngine(){
        return Part("Benz Engine");
    }   
    Part getWheels(){
        return Part("Benz Wheels");
    }
    Part getBody(){
        return Part("Benz Body");
    }
};

class Audi:public Car{
public:
    Part getEngine(){
        return Part("Audi Engine");
    }   
    Part getWheels(){
        return Part("Audi Wheels");
    }
    Part getBody(){
        return Part("Audi Body");
    }
}; …

以下代码给我一个错误。

错误：覆盖了'virtual void Animal :: getClass（）'，其中说virtual void getClass（）{cout <<“我是动物” << endl; }

错误：为'virtual int Dog :: getClass（）'指定的返回类型冲突，它说getClass（）{cout <<“我是狗” << endl; }

另外，它说：

“狗”类具有虚拟方法“ getClass”，但非虚拟析构函数

#include <iostream>
#include <vector>
#include <string>
#include <fstream>
#include<sstream>
#include <stdlib.h>     // srand, rand
#include <stdio.h>

using namespace std;

class Animal{

public:
    void getFamily(){ cout << "We are animals " << endl;}

    virtual void getClass() { cout << "I'm an animal" << endl; }
};

class Dog : public Animal{

public:
    getClass(){ cout << "I'm a …

#include<bits/stdc++.h>
using namespace std;
class A {

 public :
     ~A(){
    cout << " A is destroyed " << endl;
    }
};

class B : public A
{

 public :
     ~B(){
         cout << " B is destroyed " << endl;
    }
};
int main()
{
    B obj;
    B * p = &obj;
    delete p;
    return 0;
}

在main函数中,我只创建了一个 B类对象,它继承了A类.当我使用指针删除该对象时,析构函数被调用并打印消息然后,我无法理解为什么析构函数被调用两次？

我的问题如下:以下代码是否正确:

class A {}; // no virtual destructor

class B : public A{
    std::unique_ptr<int> ptr{new int(5)};
};

// in main
std::unique_ptr<A> = new B;

它可能会有一些编译错误,但只是理解这个概念.指针是否会被正确删除(我的意思是ptr会被删除吗？)或者我们是否需要虚拟析构函数来确保它

#include<iostream>
using namespace std;

class A
{
public:
   A() { cout << "A Creator" << endl; }
   ~A() { cout << "A Destroyer" << endl; }
};

class B : public A
{
public:
    B() { cout << "B Creator" << endl; }
    virtual ~B() { cout << "B Destroyer" << endl; }
};

void main()
{
    A* temp = new B;
    delete temp;
}

我不确定我认为这是我的想法.我当然想知道为什么错误发生了.

temp分配派生类B并将其存储在指针类型(基类A)中.

此时,编译器基于指针数据类型.

未创建虚函数表,因为基类析构函数没有虚拟声明.

B类创建一个虚函数表.还创建了虚函数表指针.

当试图破坏temp时,temp调用指针数据类型析构函数并发出问题.

无法找到B类虚函数表指针.

这是因为指针数据类型是非虚基类.

当我分配几乎相同的类但有一个成员变量为字符串而不是整数时,我有内存泄漏的问题.

带有字符串的类会产生内存泄漏,但不会产生整数.我删除了我可以删除的所有内容,但我仍然得到内存泄漏请帮忙.

所以soundbook类给我内存泄漏我不知道为什么因为我已经分配任何东西,但当我删除字符串成员我不再得到内存泄漏为什么会发生这种情况？

//主要

#include <iostream>

#include "PappersBok.h"
#include "SoundBook.h"

int main()
{
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
    Books *bk[5];

    bk[0] = new SoundBook();
    bk[1] = new PappersBok();
    bk[2] = new PappersBok();
    bk[3] = new PappersBok();
    bk[4] = new PappersBok();

    for (int i = 0; i < 5; i++)
    {
        delete bk[i];
    }


    system("pause");

    return 0;
}

// soundbook类.h和.cpp

#ifndef SOUNDBOOK_H
#define SOUNDBOOK_H


#include "books.h"

class SoundBook : public Books
{
private:
    std::string medium;
public:
    SoundBook(std::string title = "?", std::string author = …

我有兴趣编写一个打印机来输出两种不同的格式。我们称它们为 txt 和 csv。

可以在 C++ 中实现类似下面的内容吗？

class Printer {
public:
  virtual void header() = 0;
};

class CSV : Printer {
public:
 void header() { printf("csv\n"); }
};

class TXT : Printer {
public:
 void header() { printf("txt\n"); }
};

int decider(int type) {
  auto prt;
  if (type == 1) {
     prt = new CSV;
  } else {
     prt = new TXT;
  }
  prt.header();
}

如果没有，有什么替代方法可以做类似的事情？

每个C++程序员都知道,虚拟析构函数用于确保继承层次结构中对象的正确销毁顺序.

在哪里使用"虚拟析构器"/可以在实时场景中使用？

当我们有继承时，为什么我们需要一个带有动态变量的虚拟析构函数？在静态/动态情况下析构函数的执行顺序是什么？最底层派生类的析构函数不会总是先执行吗？