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();
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  Haford

构造参数的使用：

   #include<iostream>
   using namespace std;

   class tangle{
           int x;
           int y;
           public:
                   tangle();
                   tangle(int x,int y);
                  void set_x(int x);
                  void set_y(int y);
                  int get_x() {return x;}
                  int get_y() {return y;}
  };　　　　--注意分号
 
  tangle::tangle() {
          x=;
          y=;
  }
  tangle::tangle(int x,int y) {
          this->x=x;　　　　--this为指向自己的指针，不同于java的引用。
          this->y=y;
  }
  void tangle::set_x(int x) {
          this->x=x;
  }
  void tangle::set_y(int y) {
          this->y=y;
  }

  int main(int argc,char* argv[]) {
          tangle a(,);
          tangle *b=new tangle();　　　　--new创建一个对象，返回指针
          cout<<"a: "<<a.get_x()<<" "<<a.get_y()<<endl;
          cout<<"b: "<<b->get_x()<<" "<<b->get_y()<<endl;
          return ;
  }

类成员函数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=; }          //错误，有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 ;
}

补充：

如果const关键字不涉及到指针，我们很好理解，下面是涉及到指针的情况：         

int   b   =   ;
const   int*   a   =   &b;              []    

int   const   *a   =   &b;            []    

int*   const   a   =   &b;              []    

const   int*   const   a   =   &b;   []     

如果你能区分出上述四种情况，那么，恭喜你，你已经迈出了可喜的一步。不知道，也没关系，我们可以参考《effective   c++》item21上的做法，如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于星号的 右侧，const就是修饰指针本身，即指针本身是常量。因此，[1]和[2]的情况相同，都是指针所指向的内容为常量，这种情况下不允许对内容进行更改操 作，如不能*a   =   3   ；[3]为指针本身是常量，而指针所指向的内容不是常量，这种情况下不能对指针本身进行更改操作，如a++是错误的；[4]为指针本身和指向的内容均为常 量。