<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<head>
<meta http-equiv="Content-type" content="text/html; charset=utf-8" />
<title>test</title>
</head>
<body>
<script type="text/javascript" charset="utf-8">
(function(){
// this
var test=function(){
//this
return function(){
//this
};
}
(function(){
//this
var a={
p1:function(){
//this
}
};
})();
})();
</script>
</body>
</html>
为什么this在C++中被弃用？thisC++中的指针this与Java中的指针有何不同？
早期版本的C++会让this指针改变; 通过这样做,程序员可以改变方法正在处理的对象.这个功能最终被弃用了,现在C++中的这个是const.
我在四个公共金枪鱼部分得到递归构造溢出调用错误(部分=可能是一个类或其他东西？).它在教程上工作但不适合我,似乎无法看到哪里
public class tuna {
private int hour;
private int minute;
private int second;
public tuna() {
this(0,0,0); //default
}
public tuna(int h){
this(h,0,0); //with hours input
}
public tuna(int h, int m){
this(h,m,0); //with hours and minutes
}
public tuna(int h, int m, int s){
this(h,m,s); //with hours, minutes and seconds
}
我正在使用继承的子级和父级关系。我编写了一个代码，在Parent类的方法中使用“ THIS”关键字，并且在Child类中覆盖了相同的方法。当我使用'Super'关键字从子类覆盖方法调用父类方法时，在父类方法中，'THIS'关键字表示子对象类，而当我使用'THIS'关键字从父类方法调用方法时，它调用子类方法（此方法是相同的，也可以在父子类中使用覆盖方法使用）。
class Parent {
void onResume() {
println("Parent:OnResume" + this) // Here 'this' denotes Child class's Object
this.show() // here Child class's method is invoked
show() // here Child class's method is invoked as well
}
void show() {
println("Parent:Show")
}
}
class Child extends Parent {
override
void onResume() {
super.onResume()
println("Child:->OnResume" + this)
}
override
void show() {
println("Child:Show")
}
}
//Calling code
Parent parentRef = new Child()
parentRef.onResume()
如果我使用父类的引用变量创建子类的对象，例如
Parent parentRef = new Child()
然后，“ this”表示Parent类的onResume（）方法中的Child对象，当我们在Parent中调用show（）方法时，它将调用Child类的show（）方法。 …
我想写一个递归函数,它给我一个列表的长度.为了使其递归,我在List类头中的函数声明中使用此指针作为默认参数.但编译器给我一个错误......这是代码:
//Header file
#include "Nodo.h"
template < class Tipo >
class Lista
{
private:
Nodo< Tipo >* Prox;
public:
Lista();
bool ListaVuota();
int DimensioneLista(Lista<Tipo>* = this);
void InserisciInCoda(Tipo);
};
//CPP file
template< class Tipo >
int Lista< Tipo >::DimensioneLista(Lista< Tipo >* lista)
{
if(lista->ListaVuota())
return 0;
else
return 1+DimensioneLista(lista);
}
Class Player {
Player setName(String name){
this.name = name;
return this;
// or
void setName(String name){
this.name = name;
}}
你好.如果我使用"void"或"return this"语句使用该方法有什么区别？为什么"返回此"语句存在,如果它也一样？
如何传递this给operator<<在C++类？或者我只是做错了(可能).
例如,在下面的类中,我只有一个循环重复请求并打印一个整数.但是,cout<<this只打印实例的地址,但我想使用定义的运算符重载.
#include<iostream>
using std::cout; using std::endl; using std::cin;
class C {
int n;
public:
C(int n) : n(n) {};
friend std::ostream& operator<<(std::ostream&, const C&);
void set_n(int i) { n = i; }
void play() {
int input;
while (true) {
cout << this;
cin >> input;
set_n(input);
}
}
};
std::ostream& operator<<(std::ostream& os, const C& c) {
cout << c.n << "\n";
return os;
}
int main(int argc, char *argv[]) {
C c …通过this()调用重载构造函数可能有用的一个原因是它可以防止不必要的代码重复.在许多情况下,减少重复代码会减少加载类所需的时间,因为对象代码通常较小.这对于通过因特网提供的程序尤为重要,因为加载时间是一个问题.
但是,你需要小心.调用this()的构造函数的执行速度比包含所有内联初始化代码的构造函数要慢一些.这是因为调用第二个构造函数时使用的调用和返回机制会增加开销.如果你的类只用于创建少数几个对象,或者调用this()的类中的构造函数很少被使用,那么这种运行时性能的降低可能是微不足道的.
加载课程的时间如何变小？什么应该是在构造函数中使用它和使用内联代码之间的权衡点？
我最近一直在做大量的学习,我正在研究C++,以及隐藏指针(this)的主题.
这是迄今为止我见过的最复杂的话题之一.我记得this从Java,我不记得它隐藏在Java中.我记得你必须在Java中明确地使用它,但显然它在C++中是自动的.谁能证实这一点？
假设我有一个C++代码:
class A {
int x = 20;
void Interact(A* Other) {
if (x % 2 == 0) { Other->x++; x /= 2; } //some advanced operation
}
public:
void MakeInteraction(A* Other) {
Interact(Other);
Other->Interact(this);
}
};
int main() {
A a, b;
a.MakeInteraction(&b);
}
问题是,如果我想在C#中做类似的东西,我遇到了障碍 - 当然我不需要使用指针,但我不能使用this对象的引用:
class A
{
int x = 20;
void Interact(ref A Other)
{
if (x % 2 == 0) { Other.x++; x /= 2; }
}
public void MakeInteraction(ref A Other) …this ×10
java ×5
c++ ×4
constructor ×2
c# ×1
deprecated ×1
hidden ×1
inheritance ×1
invocation ×1
javascript ×1
list ×1
overloading ×1
parameters ×1
performance ×1
pointers ×1
recursion ×1
reference ×1
return ×1
scope ×1
setter ×1
this-pointer ×1
void ×1