c++類與初始化，const

--c++類與初始化，const

--------------------------------2014/09/04

1. 類的定義（頭文件、聲明文件）當作類的外部接口，通常寫成.h頭文件。

2. 類的成員函數定義（源文件）當作類的內部實現，通常寫成.cpp/.cc文件。

--成員函數定義

　　返回值 類名::函數名（參數列表） {

　　　　函數體；
}

---------------------------------------------------

--類定義

　　class 類名 {

　　成員變量

　　成員函數

};　　--注意這裏有分號，否者報錯：error: new types may not be defined in a return type

--------------------------------------------------

看一個簡單的例子：

student.h
#include<string> 
using namespace std; 
class student 
{ 
public: 
　　　　void set_name(string v_name); 
　　　　void set_age(int v_age); 
　　　　void set_school_name(string v_school_name); 
　　　　string get_name(); int get_age(); 
　　　　string get_school_name(); 
private: 
　　　　string name; 
　　　　int age; 
　　　　string school_name; };

student.cc

#include "student.h" 
void student::set_name(string v_name) 
{ name=v_name; } 
void student::set_age(int v_age) 
{ age=v_age; } 
void student::set_school_name(string v_school_name) 
{ school_name=v_school_name; } 
string student::get_name() 
{ return name; } 
int student::get_age() 
{ return age; } 
string student::get_school_name() 
{ return school_name; }

main.cc

#include<iostream>
#include "student.h" 
using namespace std; 
int main(int argc,char *argv[])
{ 
student *a=new student(); 
a->set_name("Jack"); 
a->set_age(25); 
a->set_school_name("Haford"); 
cout<<a->get_name()<<" "<<a->get_age()<<" "<<a->get_school_name()<<endl; 
} 

編譯源文件

[root@localhost student]# g++ -o main main.cc student.cc 　　--源文件編譯 
 [root@localhost student]# ./main Jack 25 Haford

構造參數的使用：

  1 #include<iostream>
  2 using namespace std;
  3 
  4 class tangle{
  5         int x;
  6         int y;
  7         public:
  8                 tangle();
  9                 tangle(int x,int y);
 10                 void set_x(int x);
 11                 void set_y(int y);
 12                 int get_x() {return x;}
 13                 int get_y() {return y;}
 14 };　　　　--注意分號 15 
 16 tangle::tangle() {
 17         x=0;
 18         y=0;
 19 }
 20 tangle::tangle(int x,int y) {
 21         this->x=x;　　　　--this爲指向本身的指針，不一樣於java的引用。 22         this->y=y;
 23 }
 24 void tangle::set_x(int x) {
 25         this->x=x;
 26 }
 27 void tangle::set_y(int y) {
 28         this->y=y;
 29 }
 30 
 31 int main(int argc,char* argv[]) {
 32         tangle a(3,4);
 33         tangle *b=new tangle();　　　　--new建立一個對象，返回指針 34         cout<<"a: "<<a.get_x()<<" "<<a.get_y()<<endl;
 35         cout<<"b: "<<b->get_x()<<" "<<b->get_y()<<endl;
 36         return 0;
 37 }

類成員函數const

    一個函數名字後有const，這個函數一定是成員函數，也就是說普通函數後面不能有const修飾，如：int print( ) const {.......} 這個函數一定爲成員函數，即在類裏面定義的函數。

    在一個類裏定義了一個const成員函數後，則此函數不能修改類中的成員變量，若是定義了一個類的const對象（非const對象能夠調用const成員函數和非const成員hanshu )，它只能調用類中的const成員函數，如：

class text{
        public:
               void print_const(void) const   { cout<<"hello"<<endl;}          //有const修飾
              void print(void) {cout<<"hello"<<endl;}            //沒有const修飾
             void getk(void)  const  {k=5; }          //錯誤，有const修飾，不能修改k的值，
      private:
             int k;
};
const text a;
int main()
{
            a.print();           //錯誤，const對象只能調用
           a.printf_const();   //正確
}
// void print() const {}  和 void print() {}   是重載函數，假如對象爲const，則調用void print () const成員函數，若是爲非const，則調用void print() ；
class text{
public:
 void print(void) const {cout<<"hello_const"<<endl;}
 void print(void) {cout<<"hello"<<endl;}
};
const text a;      
int main()
{
 a.print();    //屏幕輸出 hello_const  假如對象a 定義爲 text a,則輸出 hello
 return 0;
}

補充：

若是const關鍵字不涉及到指針，咱們很好理解，下面是涉及到指針的狀況：         

int   b   =   500; const   int*   a   =   &b;              [1] int   const   *a   =   &b;            [2] int*   const   a   =   &b;              [3] const   int*   const   a   =   &b;   [4]     

若是你能區分出上述四種狀況，那麼，恭喜你，你已經邁出了可喜的一步。不知道，也不要緊，咱們能夠參考《effective   c++》item21上的作法，若是const位於星號的左側，則const就是用來修飾指針所指向的變量，即指針指向爲常量；若是const位於星號的 右側，const就是修飾指針自己，即指針自己是常量。所以，[1]和[2]的狀況相同，都是指針所指向的內容爲常量，這種狀況下不容許對內容進行更改操 做，如不能*a   =   3   ；[3]爲指針自己是常量，而指針所指向的內容不是常量，這種狀況下不能對指針自己進行更改操做，如a++是錯誤的；[4]爲指針自己和指向的內容均爲常 量。