this指針訪問成員變數

㈠ c++中為什麼this只能在成員函數中使用

成員函數和成員變數是在類創建實例核漏之後才可以（有的改猜爛兆茄也不可以）通過所創建的實例去訪問，而靜態成員函數和靜態成員變數不用創建實例也可以訪問，this指針是創建實例後才有的，一般指向創建實例的首地址。
更多參考網路C++this指針。
以上答案僅做參考。

㈡ java中this的用法

給你說一下this的用法吧。
Java關鍵字this只能用於方法方法體內。當一個對象創建後，Java虛擬機（JVM）就會給這個對象分配一個引用自身的指針，這個指針的名字就是 this。因此，this只能在類中的非靜態方法中使用，靜態方法和靜態的代碼塊中絕對不能出現this，這在「Java關鍵字static、final 使用總結」一文中給出了明確解釋。並且this只和特定的對象關聯，而不和類關聯，同一個類的不同對象有不同的this。
說明在什麼情況下需要用到this：
第一、通過this調用另一個構造方法，用發是this(參數列表)，這個僅僅在類的構造方法中，別的地方不能這么用。
第二、函數參數或者函數中的局部變數和成員變數同名的情況下，成員變數被屏蔽，此時要訪問成員變數則需要用「this.成員變數名」的方式來引用成員變數。當然，在沒有同名的情況下，可以直接用成員變數的名字，而不用this，用了也不為錯，呵呵。
第三、在函數中，需要引用該函所屬類的當前對象時候，直接用this。
其實這些用法總結都是從對「this是指向對象本身的一個指針」這句話的更深入的理解而來的，死記不然容易忘記而且容易搞錯，要理解！

㈢ java中this的用法

1. this指當前對象。
當在一個類中要明確指出使用對象變數或函數時加上this引用。如下面例子中:

public class Hello {

String s = "Hello";

public Hello(String s){
System.out.println("s = " + s);
System.out.println("1 -> this.s = " + this.s);
this.s = s;
System.out.println("2 -> this.s = " + this.s);
}

public static void main(String[] args) {
Hello x=new Hello("HelloWorld!");
}
}

運行結果：

s = HelloWorld!
1 -> this.s = Hello
2 -> this.s = HelloWorld!

在這個例子中，構造函數Hello中，參數s與類Hello的變數s同名，這時直接對s進行操作則是對參數s進行操作。對類Hello的成員變數s進行操作就應該用this進行引用。運行結果的第一行就是直接對構造函數中傳遞過來的參數s進行列印結果；
第二行是對成員變數s的列印；第三行是先對成員變數s賦傳過來的參數s值後再列印，所以結果是HelloWorld!

2. this作為參數傳遞
當你要把自己作為參數傳遞給別的對象時如：

public class A {
public A() {
new B(this).print();
}

public void print() {
System.out.println("Hello from A!");
}
}

public class B {
A a;
public B(A a) {
this.a = a;
}

public void print() {
a.print();
System.out.println("Hello from B!");
}
}

運行結果：
Hello from A!
Hello from B!

在這個例子中，對象A的構造函數中，new
B(this)把對象A作為參數傳遞給了對象B的構造函數。

㈣ C++中this可以訪問Class的static成員嗎

可以的；比如：
#include<iostream>
using namespace std;
class circle
{
public:
circle()

{this->radius=1.0;
this->numberOfCIrcle++;
}
circle(float radius)

{
if(radius>0)
this->radius=radius;
else
this->radius=0.0;
this->numberOfCircle++;
}
static int getnumberOfCircle()
{return numberOfCircle;//鏈野毀這里不能使用對象指針this}

bool setRadius(float Radius)
{
if(radius>0) {this->radius=radius; return true;}
else return false;
}
float getRadius()
{return this->radius;}
float area()
{ return this->radius*this->radius*3.14159;}

private:
float radius;

static int numberOfCircle;

};
int citcle::numberOfCircle=0;
void main()
{
circle c1,c2(10.0);
cout<<"脊橋類circle的構造函數被調用次數："棚備<<circle::getnumberOfCircle()<<endl;
}

運行結果：
類circle的構造函數被調用次數：2

㈤ c++靜態成員函數里 為何不能使用成員變數this指針

static 成員，是在類的實力沒有創建前就存在的。
其他的成員必須是在類的實例創含寬凳建才存在。
例如：
class A {
public:
static int a;
static void func() {//靜態函數在類的實例創建之前就存在的， 在實例創建之前，根本沒有為b開辟空間

printf("%d", b);// 這個是錯誤的，因為類的實例還沒有創建，不存在b

}

int b;

};
int A::a = 5;

int main()
{
printf("%d\n", A::a);// 這個是可以的，這個時候this指針是沒談旅有指向任何實例的，可以認為是NULL，另外this是私有的指針，不巧則可能在外部使用的。

A m;//創建了一個類的實例, 這個時候b才被分配空間，才有一個this指針指向它。

printf("%d\n", m.b);

return 0;

}

㈥ c++ 子類調用基類成員函數時 this指針

1. this指針的用處:
一個對象的this指針並不是對象告晌本身的一部分，不會影響sizeof(對象)的結果。this作用域是在類內部，當在類的非靜態成員函數中訪問類的非靜態成員的時候，編譯器會自動將對象本身的地址作為一個隱含參數傳遞給函數。也就是說，即使你沒有寫上this指針，編譯器在編譯的時候也是加上this的，它作為非靜態成員函數的隱含形參，對各成員的訪問均通過this進行。
例如，調用date.SetMonth(9) <===> SetMonth(&date, 9)，this幫助完成了這一轉換 .

2. this指針的使用:
一種情況就是，在類的非靜態成員函數中返回類對象本身的時候，直接使用 return *this；另外一種情況是當參數與成員變數名相同時，如this->n = n （不能寫成n = n）。

3. this指針程序示例:
this指針是存在與類的成員函數中,指向被調用函數所在的類實例的地址。
根據以下程序來說明this指針
#include<iostream.h>
class Point
{
int x, y;
public:
Point(int a, int b) { x=a; y=b;}
void MovePoint( int a, int b){ x+=a; y+=b;}
void print(){ cout<<"x="<<x<<"y="<<y<<endl;}
};
void main( )
{
Point point1( 10,10);
point1.MovePoint(2,2);
point1.print( );
}
當對象point1調用MovePoint(2,2)函數時，即將point1對象的地址傳遞給了this指針。
MovePoint函數的原型應該是 void MovePoint( Point *this, int a, int b);第一個參數是指向該類對象的一個指針，我們在定義成員函數時沒看見是因為這個參數在類中是隱含的。這樣point1的地址傳遞給了this，所以在MovePoint函數中便顯式的寫成：
void MovePoint(int a, int b) { this->x +=a; this-> y+= b;}
即可以知道，point1調用該函數後，也就是point1的數據成員被調用並更新了值。
即該函數過程可寫成 point1.x+= a; point1. y + = b;

4. 關於this指針的一個經典回蘆肆答:
當你進入一個房子後，
你可以看見桌子、椅子、地板等，
但是房子你是看不到全貌了。
對於一個類的實例來說，
你可以看到它的成員函數、成襪嘩鋒員變數，
但是實例本身呢？
this是一個指針，它時時刻刻指向你這個實例本身

㈦ 本人java新手菜鳥，請問java this關鍵字到底指的是成員變數還是方法里的參數值

有this表示的是成員變數，沒有this修飾的就近原則，那個離他進就是哪個。比如成員變數跟參數都是握乎尺同一個名（例 int age）。在方法裡面，有this修飾的就是表示成員，沒有的就是參數。都沒有修飾，就表示是離他近的參數啦。。
當然這個回答只是回答了你的問題、
擴展一下內容吧=====
（當虛擬機創建一個對象，會創建一個指針指向自己）this就表示引用自己的指針，所以在靜態或靜態的代碼快中不能有this，因為沒有創建對象。
總結一下，其實this主要要三種用法：
1、表示頃行對當前對象的引用！
2、表示用類的成員變數，而非函數參數，注意在函數參數和成員變數同名是進行區分！其實這是第一種用法的特例，比較常用，所以那出來強調一下。
3、用於在構造方法中引用滿足指定參數類型的構造器（其實也就是構造方法）。但是這里必須非常注意：只能引用一個構造方法且必須位於開始！
還有就是注意：this不能用在static方法中！所以甚至有人給static方法的定義就是：沒有this的方法！雖然誇張，但是卻充分說明this不能在static方法中使用！
說明在什麼情況下需要用到this：
第一、通過this調用另一個構造方法，用發是this(參數列表)，這個僅僅在類的構造方法中，別的地方不能這么用。
第二、函數參數或者函數中的局部變數和成員變數同名的情況下，成員變數被屏蔽，此段高時要訪問成員變數則需要用「this.成員變數名」的方式來引用成員變數。當然，在沒有同名的情況下，可以直接用成員變數的名字，而不用this，用了也不為錯，呵呵。
第三、在函數中，需要引用該函所屬類的當前對象時候，直接用this。
其實這些用法總結都是從對「this是指向對象本身的一個指針」這句話的更深入的理解而來的，死記不然容易忘記而且容易搞錯，要理解！

㈧ c++中，類的普通成員函數通過this指針訪問普通成員變數，那訪問靜態成員變數時是怎麼實現的

靜旁讓態成員變數的位置是確定的，不要對象就可以直接訪問。

比如下面代碼稿李的兩種引用方法是等價的：

classTest{
public:
staticintms_Data;
};

intmain(){

Test鍵啟遲t;

std::cout<<t.ms_Data<<std::endl;

std::cout<<Test::ms_Data<<std::endl;

}

㈨ 為什麼一個類的空指針可以訪問類的成員函數

class MyClass{public:int i;void hello(){printf("hello/n");}void print(){printf("%d/n", i);}};void main(){MyClass* pmy = NULL;
pmy-hello();}看上面的這段代碼，似乎很詭異。 用一個空指針調用成員函數，簡直是天大的錯誤，可以遺憾的是，卻是可行的，至少對於上面的這段程序來說，不會照成錯誤。
之前運行的原因。
大家知道，每個對象，都有一個指向自己的this指針，這個指針的值，將會因為對象的不同而不同，它的作用主要就是用來區分不同的對象，這樣你就可以根據它
來訪問不同的對象的成員變數。然而，我們main函數中的hello函數並沒有使用類中的任何成員變數，所以，它也就不會用到this指針，此時的this指針是NULL。從而
我們就可以沒有障礙的使用hello函數，然而相對的是，如果你在pmy-hello()之後接著調用pmy-print()，那麼將會報空指針錯誤，因為這個函數試圖用this指針訪問成員變數i。

㈩ java中關鍵字 this 和super的作用及用法

Java關鍵字this、super使用總結

一、this
Java關鍵字this只能用於方法方法體內。當一個對象創建後，Java虛擬機（JVM）就會給這個對象分配一個引用自身的指針，這個指針的名字就是this。因此，this只能在類中的非靜態方法中使用，靜態方法和靜態的代碼塊中絕對不能出現this，這在「Java關鍵字static、final使用總結」一文拿森中給出了明確解釋。並且this只和特定的對象關聯，而不和類關聯，同一個類的不同對象有不同的this。下面給出一個使用this的綜合實例，以便說明問題：
package org.leimin;
public class Test6 {
private int number;
private String username;
private String password;
private int x = 100;
public Test6(int n) {
number = n; // 這個還可以寫為: this.number=n;
}
public Test6(int i, String username, String password) {
// 成員變數和參數同名,成員變數被屏蔽,用"this.成員變數"的方式訪問成員變數.
this.username = username;
this.password = password;
}
// 默認不帶參數的構造方法
public Test6() {
this(0, "未知", "空"); // 通過this調用另一個構造方法
}
public Test6(String name) {
this(1, name, "空"); // 通過this調用另一個構造方法
}
public static void main(String args[]) {
Test6 t1 = new Test6();
Test6 t2 = new Test6("遊客");
t1.outinfo(t1);
t2.outinfo(t2);
}
private void outinfo(Test6 t) {
System.out.println("-----------");
System.out.println(t.number);
System.out.println(t.username);
System.out.println(t.password);
f(); // 這個可以寫為: this.f();
}
private void f() {
// 局部變數與成員變消螞畝量同名,成員變數被屏蔽,用"this.成員變數"的方式訪問成員變數.
int x;
x = this.x++;
System.out.println(x);
System.out.println(this.x);
}

//返回當前實例的引用
private Test6 getSelf() {
return this;
}
}

運行結果如下：

-----------
0
未知
空
100
101
-----------
0
遊客
空
100
101

通過上面的例子，說明在什麼情況下需要用到this：

第一、通過this調用另一個構造方法，用發是this(參數列表)，這個僅僅在類的構造方法中，別的地方不能這么用。
第二、函數參數或者函數中的局部變數和成員變數同名的情況下，成員變數被屏蔽，此時要訪問成員變數則需要用「this.成員變數名」的方式來引用成員變數。當然，在沒有同名的情況下，可以直接用成員變數的名字，而不用this，用了也不為錯，呵呵。
第三、在函數中，需要引用該函所屬類的當前對象時候，直接用this。
其實這些用法總結都是從對「this是指向對象本身物扮的一個指針」這句話的更深入的理解而來的，死記不然容易忘記而且容易搞錯，要理解！
二、super
super關鍵和this作用類似，是被屏蔽的成員變數或者成員方法或變為可見，或者說用來引用被屏蔽的成員變數和成員成員方法。
不過super是用在子類中，目的是訪問直接父類中被屏蔽的成員，注意是直接父類（就是類之上最近的超類）。下面是一個綜合運用super的例子，有兩個類：一個Father類，一個Father類的子類Son，通過這兩個類完全演示了super的用法，一下是代碼：

package org.leimin;
public class Father {
public String v="Father";
public String x="輸出了Father類的public成員變數x!!!";

public Father() {
System.out.println("Father構造方法被調用!");
}

public Father(String v){
this.v="Father類的帶參數構造方法!運行了.";
}
public void outinfo(){
System.out.println("Father的outinfo方法被調用");
}
public static void main(String[] args) {
// TODO 自動生成方法存根
}
}

package org.leimin;
public class Son extends Father{
public String v="Son";

public Son() {
super(); //調用超類的構造方法,只能放到第一行.
System.out.println("Son無參數構造方法被調用!");
//super(); //錯誤的,必須放到構造方法體的最前面.
}

public Son(String str){
super(str);
System.out.println("Son帶參數構造方法被調用!");
}
//覆蓋了超類成員方法outinfo()
public void outinfo(){
System.out.println("Son的outinfo()方法被調用");
}

public void test(){

String v="哈哈哈哈!"; //局部變數v覆蓋了成員變數v和超類變數v

System.out.println("------1-----");
System.out.println(v); //輸出局部變數v
System.out.println(this.v); //輸出(子類)成員變數v
System.out.println(super.v); //輸出超類成員變數v

System.out.println("------2-----");
System.out.println(x); //輸出超類成員變數v,子類繼承而來
System.out.println(super.x); //輸出超類成員變數v

System.out.println("------3-----");
outinfo(); //調用子類的outinfo()方法
this.outinfo(); //調用子類的outinfo()方法
super.outinfo(); //調用父類的outinfo()方法
}

public static void main(String[] args) {
new Son().test();

}
}

子類Son運行結果：

Father構造方法被調用!
Son無參數構造方法被調用!
------1-----
哈哈哈哈!
Son
Father
------2-----
輸出了Father類的public成員變數x!!!
輸出了Father類的public成員變數x!!!
------3-----
Son的outinfo()方法被調用
Son的outinfo()方法被調用
Father的outinfo方法被調用

說明：次例子僅僅為了說明super的用法，實際在設計類的時候一般都盡可能私有(private)化。

通過上面的例子，下面總結一下super的用法：
第一、在子類構造方法中要調用父類的構造方法，用「super(參數列表)」的方式調用，參數不是必須的。同時還要注意的一點是：「super(參數列表)」這條語句只能用在子類構造方法體中的第一行。
第二、當子類方法中的局部變數或者子類的成員變數與父類成員變數同名時，也就是子類局部變數覆蓋父類成員變數時，用「super.成員變數名」來引用父類成員變數。當然，如果父類的成員變數沒有被覆蓋，也可以用「super.成員變數名」來引用父類成員變數，不過這是不必要的。
第三、當子類的成員方法覆蓋了父類的成員方法時，也就是子類和父類有完全相同的方法定義（但方法體可以不同），此時，用「super.方法名(參數列表)」的方式訪問父類的方法。