【C++】—— 多态

2023-11-06

目录

一、多态的概念

二、多态的定义及实现

1.多态的构成条件 

2.虚函数

3.虚函数的重写

4.虚函数重写的两个例外

1. 协变

2.析构函数的重写

5.C++11 override和final

6.重载、覆盖(重写)、隐藏(重定义)的对比

三、抽象类

1.概念 

2.接口继承和实现继承

四、多态的原理 

1.虚函数表指针

2.虚函数表

3.多态的原理

4.再次理解多态构成的条件 

五、单继承和多继承关系的虚函数表

1.单继承中的虚函数表 

1.监视窗口与内存查看 

2.使用代码查看 

2.多继承中的虚函数表 

1.监视窗口与内存查看 

2.使用代码查看 

六、继承和多态习题练习

1.概念考察 

2.问答题


一、多态的概念

        通俗来说,就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会产生出不同的状态。

        举个简单的例子:抢红包,我们每个人都只需要点击一下红包,就会抢到金额。有些人能抢到几十元,而有些人只能抢到几元甚至几毛。也正说明了不同的人做相同的事,结果却不同,这就是多态。

        在C++中有两种多态性,一种是静态的多态、一种是动态的多态;

静态的多态:函数重载,看起来调用同一个函数却有不同的行为。静态:原理是编译时实现。

动态的多态:一个父类的引用或指针去调用同一个函数,传递不同的对象,会调用不同的函数。动态:原理是运行时实现。

二、多态的定义及实现

1.多态的构成条件 

在继承中要构成多态还有两个条件:

1. 必须通过基类的指针或者引用调用虚函数。
2. 被调用的函数必须是虚函数,且派生类必须对基类的虚函数进行重写。

2.虚函数

虚函数:即被virtual修饰的类成员函数称为虚函数。

        一旦定义了虚函数,该基类的派生类中同名函数也自动成为了虚函数。也就是说在派生类中有一个和基类同名的函数,只要基类加了virtual修饰,派生类不加virtual修饰也是虚函数。

        虚函数只能是类中的一个成员函数,不能是静态成员或普通函数。

注意:我们在继承中为了解决数据冗余和二义性的问题,需要用到虚拟继承,关键字也是virtual,和多态中的virtual是没有关系的。

3.虚函数的重写

        虚函数的重写(覆盖):派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同),称子类的虚函数重写了基类的虚函数。  
//买票
class Person 
{
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};

//学生买票
class Student : public Person 
{
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};

//军人买票
class Soldier : public Person
{
public:
	void BuyTicket() { cout << "优先-买票-半价" << endl; }

};

通过对虚函数的重写,就能够实现多态:

//买票
class Person 
{
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};

//学生买票
class Student : public Person 
{
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};

//军人买票
class Soldier : public Person
{
public:
	void BuyTicket() { cout << "优先-买票-半价" << endl; }

};

//构成多态,传的哪个类型的对象,调用的就是这个类型的虚函数 --- 跟对象有关
//不构成多态,调用就是P的类型 --- 跟类型有关
void Func(Person& p) //或void Func(Person* p)
{
	p.BuyTicket();   //p->BuyTicket(); 
}

int main()
{
	Person ps;
	Func(ps);   //没有任何身份去买票,一定是全价

	Student st;
	Func(st);   //以学生的身份去买票,是半价

	Soldier so;
	Func(so);   //以军人的身份去买票,是优先并且半价

	return 0;
}

4.虚函数重写的两个例外

1. 协变

协变(基类与派生类虚函数返回值类型不同)
        派生类重写基类虚函数时,与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用,派生类虚函数返回派生类对象的指针或者引用时,称为协变。  
class Person 
{
public:
	virtual Person* BuyTicket() { cout << "买票-全价" << endl; return new Person; }
};

class Student : public Person 
{
public:
	virtual Student* BuyTicket() { cout << "买票-半价" << endl; return new Student; }
};

class Soldier : public Person
{
public:
	virtual Soldier* BuyTicket() { cout << "优先-买票-半价" << endl; return new Soldier; }
};


void Func(Person& p)
{
	p.BuyTicket(); 
}

int main()
{
	Person ps;
	Func(ps);

	Student st;
	Func(st);

	Soldier so;
	Func(so);

	return 0;
}

2.析构函数的重写

基类与派生类析构函数的名字不同 

        如果基类的析构函数为虚函数,此时派生类析构函数只要定义,无论是否加virtual关键字,都与基类的析构函数构成重写,虽然基类与派生类析构函数名字不同。虽然函数名不相同,看起来违背了重写的规则,其实不然,这里可以理解为编译器对析构函数的名称做了特殊处理,编译后析构函数的名称统一处理成destructor。
class Person 
{
public:
	// ~Person() { cout << "~Person()" << endl; }//1
	virtual ~Person() { cout << "~Person()" << endl; }//2
};

class Student : public Person 
{
public:
	// ~Student() { cout << "~Student()" << endl; }//1
	virtual ~Student() { cout << "~Student()" << endl; }//2
};


int main()
{
	//普通对象,析构函数是否是虚函数,是否完成重写,都能正确调用
	Person p;
	Student s;

	//动态申请的父子对象,如果给了父类指针管理,那么需要析构函数是虚函数
	Person* p1 = new Person;//operator new + 构造函数
	Person* p2 = new Student;
	delete p1;//析构函数 operator + delete
	delete p2;

	return 0;
}

普通对象去调用析构时:无论是否是多态都能正确调用

动态申请的父子对象,如果给了父类指针管理,那么需要析构函数是虚函数:

        由下图1的运行结果可以看到,如果析构函数不是虚函数的话,他析构了子类中父类的那一部分。但不能析构子类的部分,从而造成内存泄露。如果想达到析构的目的,就必须是多态,但此时的析构函数之差两个条件就满足了:虚函数和函数名相同;函数名编译器已经做了特殊处理,及都改为了destructor,所以我们就需要加上virtual 来实现多态。

5.C++11 override和final

        从上面可以看出,C++对函数重写的要求比较严格,但是有些情况下由于疏忽,可能会导致函数名字母次序写反而无法构成重载,而这种错误在编译期间是不会报出的,只有在程序运行时没有得到预期结果才来debug会得不偿失,因此:C++11提供了override和fifinal两个关键字,可以帮助用户检测是否重写。

1. fifinal:修饰虚函数,表示该虚函数不能再被重写。

class A final //直接限制不能被继承(也称最终类)
{
private:
	A(int a = 0)
		:_a(a)
	{}
protected:
	int _a;
};

class B :public A //不能被继承
{

};
/****************************************************/
class c 
{
public:
	virtual void f() final//限制它不能被子类中的虚函数重写
	{
		cout << "c::f()" << endl;
	}
};

class d :public c
{
public:
	virtual void f() //不能被重写
	{
		cout << "d::f()" << endl;
	}
};

2. override: 检查派生类虚函数是否重写了基类某个虚函数,如果没有重写编译报错。

class Car 
{
public:
	virtual void Drive()
	{}
};

class Benz :public Car 
{
public:
	virtual void Drive() override //检查是否完成重写
	{ cout << "Benz-舒适" << endl; }
};

6.重载、覆盖(重写)、隐藏(重定义)的对比

三、抽象类

1.概念 

        在虚函数的后面写上 = 0 ,则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类(也叫接口类),抽象类不能实例化出对象。

//抽象类
class Car
{
public:
	virtual void Drive() = 0;//纯虚函数 
};

int main()
{
	Car c;//抽象类不能实例化出对象
    return 0;
}

        派生类继承后也不能实例化出对象,只有重写纯虚函数,派生类才能实例化出对象。纯虚函数规范了派生类必须重写,另外纯虚函数更体现出了接口继承。

class Car
{
public:
	//纯虚函数一般只声明,不实现(可以实现,但没有价值,因为不能实例化出对象,可以定义指针或引用)
	virtual void Drive() = 0;
};

class Benz :public Car
{
public:
	virtual void Drive()
	{
		cout << "Benz-舒适" << endl;
	}
};

class BMW :public Car
{
public:
	virtual void Drive()
	{
		cout << "BMW-操控" << endl;
	}
};

int main()
{
    //派生类只有重写了虚函数才能实例化出对象
    Benz b1;
	BMV b2;
    //通过基类的指针去调用不同对象的函数
	Car* pBenz = new Benz;
	pBenz->Drive();
	Car* pBMW = new BMW;
	pBMW->Drive();
}

2.接口继承和实现继承

  • 普通函数的继承是一种实现继承,派生类继承了基类函数,可以使用函数,继承的是函数的实现。
  • 虚函数的继承是一种接口继承,派生类继承的是基类虚函数的接口,目的是为了重写,达成多态,继承的是接口。
  • 所以如果不实现多态,不要把函数定义成虚函数。

四、多态的原理 

1.虚函数表指针

这里常考一道笔试题:sizeof(Base)是多少? 

class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
	char ch = 'A';
};

int main()
{
	Base bb;
	cout << sizeof(Base) << endl;
	return 0;
}

        可能刚看到这个题目的时候,都会觉得答案是8个字节,但是我们在打印后却发现是12个字节;这是为什么呢?

        因为有了虚函数,这个对象里面就多了一个成员,虚函数表指针__vfptr。

2.虚函数表

        对象中的这个指针叫做虚函数表指针,简称虚表指针,虚表指针指向一个虚函数表,简称虚表,每一个含有虚函数的类中都至少有一个虚表指针。那么这个虚表中到底是什么呢?

我们通过下面的程序来进行分析:

class Base
{
public:
	virtual void Func1() { cout << "Base::Func1()" << endl; }
	virtual void Func2() { cout << "Base::Func2()" << endl; }
	void Func3() { cout << "Base::Func3()" << endl; }
private:
	int _b = 1;
};

class Derive : public Base
{
public:
	virtual void Func1() { cout << "Derive::Func1()" << endl; }
private:
	int _d = 2;
};
int main()
{
	Base b;
	Derive d;
	return 0;
}

        

通过观察和测试,我们发现了以下几点问题:
  1. 派生类对象d中也有一个虚表指针,d对象由两部分构成,一部分是父类继承下来的成员,另一部分是自己的成员。
  2. 基类b对象和派生类d对象虚表是不一样的,这里我们发现Func1完成了重写,所以d的虚表中存的是重写的Derive::Func1,所以虚函数的重写也叫作覆盖,覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法,覆盖是原理层的叫法。
  3. 另外Func2继承下来后是虚函数,所以放进了虚表,Func3也继承下来了,但是不是虚函数,所以不会放进虚表。
  4. 虚函数表本质是一个存虚函数指针的指针数组,一般情况这个数组最后面放了一nullptr。
  5. 总结一下派生类的虚表生成:a.先将基类中的虚表内容拷贝一份到派生类虚表中; b.如果派生类重写了基类中某个虚函数,用派生类自己的虚函数覆盖虚表中基类的虚函数;c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

3.多态的原理

未实现多态时: 

class Base
{
public:
	virtual void Func1() { cout << "Base::Func1()" << endl; }

private:
	int _b = 1;
};

class Derive : public Base
{
private:
	int _d = 2;
};

int main()
{

	Base b;
	Derive d;

	Base* p1 = &b;
	p1->Func1();
	p1 = &d;
	p1->Func1();

	return 0;
}

 实现了多态:

class Base
{
public:
	virtual void Func1() 
	{ cout << "Base::Func1()" << endl; }

	virtual void Func2() 
	{ cout << "Base::Func2()" << endl; }

	void Func3() 
	{ cout << "Base::Func3()" << endl; }
private:
	int _b = 1;
};

class Derive : public Base
{
public:
	virtual void Func1() 
	{ cout << "Derive::Func1()" << endl; }
private:
	int _d = 2;
};
int main()
{
	Base b;
	Derive d;
	Base* p1 = &b;
	p1->Func1();
	p1 = &d;
	p1->Func1();
	return 0;
}

4.再次理解多态构成的条件 

为什么必须要是父类的指针或引用来调用虚函数,为什么不能是对象调用?

        指针和引用调用、对象调用本质上是子类切片完成的,指针和引用的切片只针对子类中父类的那一部分,其他都不管,只管与父类一样的内容(虚表中)切片过去;如果是对象切片,就是将虚表里的内容全部切片过去(因为都是要调用构造函数的),那么就有可能父类也指向了子类的虚表,那就乱套了;

        可以理解为:指针和引用是将虚表的指针拷贝过去了,对象是将虚表中的内容拷贝过去了;

五、单继承和多继承关系的虚函数表

1.单继承中的虚函数表 

class Base
{
public:
	virtual void func1() { cout << "Base::func1" << endl; }
	virtual void func2() { cout << "Base::func2" << endl; }
private:
	int a = 1;
};

class Derive :public Base 
{
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
	virtual void func4() { cout << "Derive::func4" << endl; }
private:
	int b = 1;
};

int main()
{
	Base b;
	Derive d;
	return 0;
}

1.监视窗口与内存查看 

2.使用代码查看 

观察下图中的监视窗口中我们发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数,也可以认为是他的一个小bug。那么我们如何查看d的虚表呢?下面我们使用代码打印出虚表中的函数。

typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
	// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
	cout << " 虚表地址>" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
		VFPTR f = vTable[i];
		f();
	}
	cout << endl;
}
int main()
{
	Base b;
	Derive d;
	VFPTR* vTableb = (VFPTR*)(*(int*)&b);
	PrintVTable(vTableb);
	VFPTR* vTabled = (VFPTR*)(*(int*)&d);
	PrintVTable(vTabled);
	return 0;
}

思路:取出b、d对象的头4bytes,就是虚表的指针,前面我们说了虚函数表本质是一个存虚函数指针的指针数组,这个数组最后面放了一个nullptr

  1. 先取b的地址,强转成一个int*的指针
  2. 再解引用取值,就取到了b对象头4bytes的值,这个值就是指向虚表的指针
  3. 再强转成VFPTR*,因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
  4. 虚表指针传递给PrintVTable进行打印虚表
  5. 需要说明的是这个打印虚表的代码经常会崩溃,因为编译器有时对虚表的处理不干净,虚表最后面没有放nullptr,导致越界,这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案,再编译就好了。

 

2.多继承中的虚函数表 

class Base1
{
public:
	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }
private:
	int b1;
};

class Base2
{
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }
private:
	int b2;
};

class Derive : public Base1, public Base2 
{
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
private:
	int d1;
};

1.监视窗口与内存查看 

 

2.使用代码查看 

typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
	cout << " 虚表地址>" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
		VFPTR f = vTable[i];
		f();
	}
	cout << endl;
}

int main()
{
	Derive d;
	VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
	PrintVTable(vTableb1);
	VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
	PrintVTable(vTableb2);
	return 0;
}

六、继承和多态习题练习

1.概念考察 

1. 下面哪种面向对象的方法可以让你变得富有( A )
        A: 继承         B: 封装         C: 多态         D: 抽象
2. ( D )是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关,而对方法的 调用则可以关联于具体的对象。
        A: 继承         B: 模板         C: 对象的自身引用         D: 动态绑定
3. 面向对象设计中的继承和组合,下面说法错误的是?( C )
        A:继承允许我们覆盖重写父类的实现细节,父类的实现对于子类是可见的,是一种静态复用,也称为白盒复用
        B:组合的对象不需要关心各自的实现细节,之间的关系是在运行时候才确定的,是一种动态复用,也称为黑盒复用
        C:优先使用继承,而不是组合,是面向对象设计的第二原则
        D:继承可以使子类能自动继承父类的接口,但在设计模式中认为这是一种破坏了父类的封装性的表现
4. 以下关于纯虚函数的说法,正确的是( A )
        A:声明纯虚函数的类不能实例化对象         B:声明纯虚函数的类是虚基类
        C:子类必须实现基类的纯虚函数                D:纯虚函数必须是空函数
5. 关于虚函数的描述正确的是( B )
        A:派生类的虚函数与基类的虚函数具有不同的参数个数和类型
        B:内联函数不能是虚函数
        C:派生类必须重新定义基类的虚函数
        D:虚函数可以是一个static型的函数
6. 关于虚表说法正确的是( D 
        A:一个类只能有一张虚表
        B:基类中有虚函数,如果子类中没有重写基类的虚函数,此时子类与基类共用同一张虚表
        C:虚表是在运行期间动态生成的
        D:一个类的不同对象共享该类的虚表
7. 假设A类中有虚函数,B继承自A,B重写A中的虚函数,也没有定义任何虚函数,则(D
        A:A类对象的前4个字节存储虚表地址,B类对象前4个字节不是虚表地址
        B:A类对象和B类对象前4个字节存储的都是虚基表的地址
        C:A类对象和B类对象前4个字节存储的虚表地址相同
        D:A类和B类虚表中虚函数个数相同,但A类和B类使用的不是同一张虚表
8. 下面程序输出结果是什么? ( A )
        A:class A class B class C class D         B:class D class B class C class A
        C:class D class C class B class A         D:class A class C class B class D
#include<iostream>
using namespace std;
class A {
public:
	A(char* s) { cout << s << endl; }
	~A() {}
};

class B :virtual public A {
public:
	B(char* s1, char* s2) :A(s1) { cout << s2 << endl; }
};

class C :virtual public A 
{
public:
	C(char* s1, char* s2) :A(s1) { cout << s2 << endl; }
};

class D :public B, public C
{
public:
	D(char* s1, char* s2, char* s3, char* s4) :B(s1, s2), C(s1, s3), A(s1)
	{
		cout << s4 << endl;
	}
};

int main() 
{
	D* p = new D("class A", "class B", "class C", "class D");
	delete p;
	return 0;
}
9. 多继承中指针偏移问题?下面说法正确的是( C )
        A:p1 == p2 == p3         B:p1 < p2 < p3
        C:p1 == p3 != p2          D:p1 != p2 != p3
class Base1 { public: int _b1; };
class Base2 { public: int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
int main()
{
	Derive d;
	Base1* p1 = &d;
	Base2* p2 = &d;
	Derive* p3 = &d;
	return 0;
}
10. 以下程序输出结果是什么( B )
        A: A->0              B: B->1                    C: A->1        
        D: B->0             E: 编译出错              F: 以上都不正确
class A 
{
public:
	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
	virtual void test() { func(); }
};

class B : public A
{
public:
	void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};

int main(int argc, char* argv[])
{
	B* p = new B;
	p->test();
	return 0;
}

2.问答题

1. 什么是多态?
        多态首先是建立在继承的基础上的,先有继承才能有多态。多态是指不同的子类在继承父类后分别都重写覆盖了父类的方法,即父类同一个方法,在继承的子类中表现出不同的形式。
2. 什么是重载、重写(覆盖)、重定义(隐藏)?
3. 多态的实现原理?
        当子类继承了父类的虚函数并完成重写,则就构成了多态,其底层是父类和子类都有一个虚表指针指向了一个虚表,这个虚表是用来存放虚函数的地址的(不是真正的地址,可以理解为间接地址),当父类的指针和引用来调用虚函数时,取决于对象本身(即接受的父类就调用父类,接受的是子类就调用子类),父类和子类就会分别去各自的虚表指针里找到相应的虚函数。
4. inline函数可以是虚函数吗?
        可以,不过编译器就忽略inline属性,这个函数就不再是inline,因为虚函数要放到虚表中去。
5. 静态成员可以是虚函数吗?
        不能,因为静态成员函数没有this指针,使用类型::成员函数的调用方式无法访问虚函数表,所以静态成员函数无法放进虚函数表。
6. 构造函数可以是虚函数吗?
        不能,因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。
7. 析构函数可以是虚函数吗?什么场景下析构函数是虚函数?
        可以,并且最好把基类的析构函数定义成虚函数。
8. 对象访问普通函数快还是虚函数更快?
        首先如果是普通对象,是一样快的。如果是指针对象或者是引用对象,则调用的普通函数快,因为构成多态,运行时调用虚函数需要到虚函数表中去查找。
9. 虚函数表是在什么阶段生成的,存在哪的?
        虚函数表是在编译阶段就生成的,一般情况下存在代码段(常量区)的。
10. C++菱形继承的问题?虚继承的原理?
        菱形继承的问题是子类对象当中会有两份父类的成员,因此会导致数据冗余和二义性的问题。
        虚继承对于相同的虚基类在对象当中只会存储一份,若要访问虚基类的成员需要通过虚基表获取到偏移量,从而找到相应的虚基类成员,解决了数据冗余和二义性的问题。
11. 什么是抽象类?抽象类的作用?
        有纯虚拟函数的类称为抽象类,它不能生成对象;抽象类强制子类必须重写虚函数,否则无法实例化对象;另外抽象类体现出了接口继承关系。

        

本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系:hwhale#tublm.com(使用前将#替换为@)

【C++】—— 多态 的相关文章

  • 从 SQL 数据库获取日期时间

    我的数据库表中有一个 DateTime 记录 我编写一个查询从数据库中获取它 string command2 select Last Modified from Company Data where Company Name Descrip
  • 如何自定义 DataTable 列的排序

    我需要对数据表列的值进行排序 该列包含字符串 整数或混合文本 例如 数据表列包含如下值 23 18 12 store 23 store a1 1283 25 如果我使用对值进行排序Dataview sort 方法会按此顺序产生 12 128
  • 如何从当前 .NET 表单/应用程序发送密钥 F12

    我非常确定以下按钮激活的表单代码应该在我的 C 应用程序中引发 Control F12 SendKeys F12 但它似乎并没有继续进入 Windows shell 并激活另一个正在侦听它的程序 我的键盘可以用 看起来发送键在某处被拦截 并
  • 如何调试参数化 SQL 查询

    我使用 C 连接到数据库 然后使用 Ad hoc SQL 来获取数据 这个简单的 SQL 查询非常方便调试 因为我可以记录 SQL 查询字符串 如果我使用参数化 SQL 查询命令 有没有办法记录 sql 查询字符串以进行调试 我想就是这样的
  • 测试 hdf5/c++ 中的组是否存在

    我正在打开一个现有的 HDF5 文件来附加数据 我想向那个叫做的小组保证 A存在以供后续访问 我正在寻找一种简单的方法来创建 A有条件地 如果不存在则创建并返回新组 或者返回现有组 一种方法是测试 A存在 我怎样才能高效地做到这一点 根据
  • 如何在 C# 事件中区分更改是由代码还是由用户进行?

    我有一个简单的TextBox一开始是空的 我有一个简单的事件 TextChanged 可以知道用户何时更改了其中的任何内容TextBox 但是 如果我自己在代码中对其执行任何操作 该事件就会触发 喜欢设置textbox Text Test
  • 为什么C Clock()返回0

    我有这样的事情 clock t start end start clock something else end clock printf nClock cycles are d d n start end 我总是得到输出 时钟周期是 0
  • 在 Windows Phone 上启动 pdf 文件时出现 System.Runtime.InteropServices.COMException

    我正在尝试使用我之前在另一个应用程序上使用过的以下工作代码打开 pdf 文件 但这一次 当流程到达此行时 我收到 System Runtime InteropServices COMException Windows System Laun
  • 组合 Datepicker 和 Timepicker 值 Win 8.1

    我试图同时使用 Datepicker Timepicker 来返回可以存储在数据库中的 DateTime 例如 我想要安排会议的开始日期和结束日期 如果适用 我将如何将这些值组合成 SQL 数据库可以处理的正确格式 任何反馈都会很棒 我让这
  • 控制台应用程序 .net Core 2.0 的配置

    在 net Core 1 中我们可以这样做 IConfiguration config new ConfigurationBuilder AddJsonFile appsettings json true true Build 这样就可以使
  • 如何检测斑点并将其裁剪成 png 文件?

    我一直在开发一个网络应用程序 我陷入了一个有问题的问题 我会尝试解释我想要做什么 在这里您看到第一个大图像 其中有绿色形状 我想要做的是将这些形状裁剪成不同的 png 文件 并使它们的背景透明 就像大图像下面的示例裁剪图像一样 第一张图像将
  • CMake - 将预构建库链接到 C# 项目

    我正在使用 CMake 构建 C 库 该库依赖于已构建的库 dll 我似乎无法让图书馆链接到我的图书馆 我尝试过使用target link libraries mylib external lib 我也尝试过暴力破解 reference e
  • _mm_max_ss 在 clang 和 gcc 之间有不同的行为

    我正在尝试使用 clang 和 gcc 交叉编译一个项目 但在使用时发现一些奇怪的差异 mm max ss e g m128 a mm set ss std numeric limits
  • 在 C# 中赋值后如何保留有关对象的信息?

    我一直在问我的想法可能是解决方案 https stackoverflow com questions 35254467 is it possible in c sharp to get the attributes attached to
  • 标准 C 中的 sizeof 与 sizeof()? [复制]

    这个问题在这里已经有答案了 我看到一些直接使用 sizeof 的代码 想知道它是否是标准 C 令我惊讶的是 它运行得很好 这是一个例子 include
  • C# ToString("MM/dd/yy") 删除前导 0 [重复]

    这个问题在这里已经有答案了 可能的重复 格式化 NET DateTime Day 不带前导零 https stackoverflow com questions 988353 format net datetime day with no
  • 为什么我不能在扩展 List 的类中调用 OrderBy?

    我有一堂课 Deck 其中包含一个名为的方法Shuffle 我正在致力于重构Deck延长List
  • 在 MVVM 中,可以在视图后面的代码中访问 ViewModel 吗?

    在 MVVM 模式中 是否可以接受甚至可以访问视图代码后面的 ViewModel 属性 我有一个可观察的集合 它填充在 ViewModel 中 我需要在视图中使用它来绑定到带有链接列表的无限滚动条 IE private LinkedList
  • 在 unix 中编译 dhrystone 时出错

    我是使用基准测试和 makefile 的新手 我已经从下面的链接下载了 Dhrystone 基准测试 我正在尝试编译它 但我遇到了奇怪的错误 我尝试解决它 但没有成功 有人可以帮助我运行 dhrystone 基准测试吗 以下是我尝试编译的两
  • 宏观评价[重复]

    这个问题在这里已经有答案了 可能的重复 未定义的行为和序列点 https stackoverflow com questions 4176328 undefined behavior and sequence points 我无法理解以下宏

随机推荐

  • Oracle常见问题定位方法

    Oracle在安装时无法正常显示出安装界面 现象 在vnc的界面中 安装时提示 Can t connect to X11 window server using 1 0 as the value of the DISPLAY variabl
  • 使用注解开发springmvc

    第三步 pom xml文件引入相关依赖 主要有Spring框架核心库 Spring MVC servlet JSTL等 第四步 配置web xml 映射路径 不要为 会404 第六步 创建Controller RequestMapping
  • 某宝滑块ua特征研究

    从137版本开始某宝新加了x 82类型滑块 和之前无感或者滑动验证js 类似 不过浏览器特征检测 反调试干扰都增加了不少 变得更有难度 下面稍微讲下研究过程 首先处理大量三目运算符 这个没啥好办法 博主用ast处理的 类似下面这种 单步调试
  • 贪心算法求解TSP问题(python)

    这里使用贪心算法求解TSP问题的python版本 dist 为距离矩阵 start index 为起始位置 def tsp quick dist list start index int sum distance seq result n
  • 用C++做一颗会跳动的爱心

    先来看看效果 程序描述 程序先以较慢的速度画一个大爱心 之后跳动的心其实从视觉上看就是一大一小两个心相互切换 但是要调整一下大小爱心变化时的时间间隔 代码主要是通过设置两个函数 利用cls来清屏 重复打印大心和小心 并设置颜色为红色 详细代
  • php公众号获取code,微信公众号获取code

    methods getCode 非静默授权 第一次有弹框 this code var local window location href 获取页面url var appid wx65adcf075369 this code this ge
  • 使用LFM(Latent factor model)隐语义模型进行Top-N推荐

    最近在拜读项亮博士的 推荐系统实践 系统的学习一下推荐系统的相关知识 今天学习了其中的隐语义模型在Top N推荐中的应用 在此做一个总结 隐语义模型LFM和LSI LDA Topic Model其实都属于隐含语义分析技术 是一类概念 他们在
  • Windows 下如何安装配置Snort视频教程

    Windows 下如何安装配置Snort视频教程 第一步 http www tudou com programs view UUbIQCng360 第二部 http www tudou com programs view NqcPETQk2
  • 【算法】算法学习三:递归算法 & 栈

    文章目录 一 递归的含义 二 基线条件和递归条件 三 栈 3 1 什么是栈 3 2 调用栈 3 3 递归调用栈 一 递归的含义 递归算法是一种解决问题的方法 其中函数在执行过程中调用自身 它通过将一个大问题拆分成一个或多个相似的子问题 并逐
  • 数据倾斜2

    数据倾斜的原因和解决方案 MapReduce简介 MapReduce是面向大数据并行处理的计算模型 框架和平台 它隐含了以下三层含义 1 MapReduce是一个基于集群的高性能并行计算平台 Cluster Infrastructure 它
  • 文件上传到Linux服务器常用方法

    本文介绍几种常见的方法 把文件上传到Linux服务器中 常见有使用 scp命令 xshell软件里的xftp程序 U盘挂载 服务器自带的lrzsz程序 一 scp使用说明 1 把本机的文件传给目的服务器 linux linux scp ge
  • 修改Windows的git bash的主题(样式)

    背景 Windows的git bash页面默认是黑白的 如何改成别的颜色 PS 我一直不太喜欢黑色主题的软件 有几个原因 大多软件是白色的 看久了黑色切换到其他软件的时候眼睛不适应 字体等对比不强 我真的不知道为啥这么多人喜欢IDEA黑色主
  • 数组类型方法

    数组类型方法 1 concat 创建一个新数组 将array与任何数组 或 值连接在一起 let arr 1 2 3 4 let arr2 9 let arr3 arr concat arr2 console log arr3 1 2 3
  • jQuery操作类样式(增加、移除、判断)

    一 增加和移除一个或多个类样式的方法 1 增加一个类样式的方法 1 当前需要增加样式的元素 addClass cls 注意在addClass方法中类样式的名字前面没有点 2 增加多个类样式的方法 1 第一种写法 当前需要增加样式的元素 ad
  • 最新Landsat数据下载教程

    目前 国内下载Landsat数据可以通过USGS网站或者地理空间数据云下载 由于USGS对Landsat数据进行了修改 地理空间数据云目前只存储有2017年5月之前的数据 本文只介绍从USGS网站下载Landsat数据 USGS有两个网站可
  • mysql: using the Connector/J connection property ‘autoReconnect=true‘ to avoid this problem

    报错信息 com mysql cj jdbc exceptions CommunicationsException The last packet successfully received from the server was 1 12
  • 怎么使用Web Workers提升性能?

    一 概述 Web Workers 使得一个Web应用程序可以在与主执行线程分离的后台线程中运行一个脚本操作 这样做的好处是可以在一个单独的线程中执行费时的处理任务 从而允许主 通常是UI 线程运行而不被阻塞 它的作用就是给JS创造多线程运行
  • samba linux命令,Linux下的samba命令技巧

    昨天想DX学习了的Linux命令 当我想独占服务器上的A文件上 发现已经有用户正在使用 可以打下如下命令 smbstatus grep DEF M 显示如下 albert koidemrp smbstatus grep DEF M PID
  • centos使用sh脚本启动jar包

    centos使用sh脚本启动jar包 1 可以在windows上编辑好 上传至服务器 也可以在centos中直接新建文件 文件以 sh命名 例如 demo sh abc sh bin bash name jar包启动脚本 jar包所在位置
  • 【C++】—— 多态

    目录 一 多态的概念 二 多态的定义及实现 1 多态的构成条件 2 虚函数 3 虚函数的重写 4 虚函数重写的两个例外 1 协变 2 析构函数的重写 5 C 11 override和final 6 重载 覆盖 重写 隐藏 重定义 的对比 三