--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]为指针本身和指向的内容均为常 量。