C++学习笔记（2）-类

最新推荐文章于 2022-03-29 16:42:27 发布

daichunkai123

最新推荐文章于 2022-03-29 16:42:27 发布

阅读量306

点赞数

文章标签： C++

本文链接：https://blog.csdn.net/daichunkai123/article/details/77941485

版权

C++中的类

类的定义使用class表示，他的格式如下：

calss classname
 {
  public：
  变量类型1 变量名称1;
  变量类型2 变量名称2;
  变量类型3 变量名称3;
 };

则在后续的使用的过程中，其结构如下：
classname a1;
classname a2;
例子如下：

#include <iostream>
using namespace std;
#define CS 10
class Box
{
public:
    int a;
    int b;
    int c;
};
int main(){
    const int cs=2;
    int result;
    Box b1;
    b1.a=1;
    b1.b=2;
    b1.c=3;
    result=b1.a * b1.b *b1.c * cs;
    cout << result << endl;
    return 0;
}

输出是
12
注意：class{};后面有个“;”不能忘记

类的成员函数

类的成员函数是指定义在class name{函数};中的函数，其情况和C语言中的函数声明一致
例子：

class test
{
public:
    int a;
    int b;
    int c;
    int chengji(int a,int b,int c)
    {
       return a *b * c;
    }
};
或者是
class test
{
public:
    int a;
    int b;
    int c;
    int chengji(int a,int b,int c);
};
int test::chengji(int a,int b, int c)
{
return a * b * c;
}

类的成员函数调用方法：

int result;
test test1;
test1.a=10;
test1.b=11;
text1.c=12;
result=test1.chengji(test1.a,test1.b,test1.c);

例子：

#include <iostream>
using namespace std;
class vum
{
public:
   int a;
   int b;
   int c;
   int chengji(int a,int b,int c)
     {
       int result;
       result=a*b*c;
       return result;
     }
};
class add
{
public:
   int a;
   int b;
   int c;
   int jia (int a,int b,int c);
};
int add::jia(int a,int b,int c)
{
   return a+b+c;
}
int main()
{
   vum box;
   add lang;
   int result;
   box.a=1;
   box.b=2;
   box.c=3;
   result=box.chengji(box.a,box.b,box.c);
   cout << result << endl;
   lang.a=2;
   lang.b=3;
   lang.c=4;
   result=lang.jia(lang.a,lang.b,lang.c);
   cout << result << endl;
   return 0;
}

输出：

6
9

注意：class中不要忘记加上public ，private等

C++中类访问修饰符

1、C++中类成员修饰符包括三种：public（共有成员），protected（受保护成员），private（私有成员）
2、类成员修饰符的作用范围是从“：”后开始，一直到class类结束的右括号或者是下一个修饰符。
3、如果没有标记，那么默认成员修饰符是private;

class Base {

   public:

  // 公有成员

   protected:

  // 受保护成员

   private:

  // 私有成员

};

public修饰符：public修饰符修饰的类成员能够被直接访问例如上述的“lang.a=2”,也能够被成员函数访问
private修饰符：只有类和友元函数才能访问，一般都是用来保护数据，很少定义函数，被private修饰的类成员能够被public或者private函数调用。
一般都是在私有域定义相关数据，在共有域定义相关函数。
例子

#include <iostream>
using namespace std;
class vum
{
private:
   int a;    //a是私有成员
public:
   int b;
   int c;
   int chengji(int a,int b,int c)   //返回a，b，c的乘积
     {
       int result;
       result=a*b*c;
       return result;
     }
   void seta(int ao)//设置私有成员a，只能通过public修饰的成员函数访问
    {
       a=ao;
    }
    int get()   //等号左边的都是类成员
    {
       return a;
    }
};
class add
{
private:
   int a;
public:
   int b;
   int c;
   int jia (int a,int b,int c);
private:
   int seta(int bo);
   int geta();
};
int add::geta()     //class之外说明函数
{
   return a;
}
int add::jia(int a,int b,int c)
{  
   return seta(a)+b+c;   //共有成员函数jia调用私有成员函数seta，之后seta调用私有成员函数geta
}
int add::seta(int ao)
{
     a=ao+100;
     return geta();
}
int main()
{
   vum box;
   add lang;
   int result;
   //box.a=1;                        //不能够直接访问
   box.seta(2);
   box.b=2;
   box.c=3;
   result=box.chengji(box.get(),box.b,box.c);
   cout << result << endl;
   //lang.a=2;                     //不能够直接访问，只能通过成员函数访问
   result=lang.jia(1,3,4);
   lang.b=3;
   lang.c=4;
   //result=lang.jia(lang.a,lang.b,lang.c);
   cout << result << endl;
   return 0;
}

protected修饰符：其用法与private基本一致，惟一的区别是protected修饰符修饰的变量在派生类中是可以访问的。
有关派生类与继承：
继承是将基类（原先的class）扩充到派生类的过程中，也就是将基类加入到派生类的过程
方式：

class A   //基类A
{
   ...
};
class B ：[继承方式] A
{
   ...
};

注意，class中的函数如果有输入变量，那么输出的是对应输入变量的运算，如果没有输入变量，则默认的是类中的变量进行运算
例子：

#include <iostream>
using namespace std;
class Box
{
public:
    int a;
    int add(int b);
    Box();
    int getb();
    void setb(int b);
    void setmm(int mm);
protected:
    int b;
private:
    int c;
};
int Box::add(int b)   //b不是初始化之后的b，而是输入的值，这里b=1000
{
    return b+c;      //b=1000，c=3（初始化结果是b=3，c=4），但是这里的b是指传入的数。
}
int Box::getb(){
    return b;
}
void Box::setb(int b)         //这个b不能影响到class中的b
{
    b=b;                       
}
void Box::setmm(int mm)         //mm将值赋值给类中的b
{
    b=mm;                       
}
Box::Box()                      //初始化
{
    a=2;
    b=3;
    c=4;
    cout << "successful" << endl;
}
class Box1:protected Box
{
public:
    int a;
    int cheng(int b,int c);
    Box1();
};
int Box1::cheng(int c,int b)
{
    return b*c;
}
Box1::Box1(){
    //a=5;
    cout << "Box1 successful" << endl;
}
int main(void)
{
    Box m;
    Box1 n;
    cout << m.a << endl;             //a=2
    cout << n.a << endl;             //Box中的a是public，Box1中protected继承不能够直接访问Box中的a，但是此处能够访问，说明如果是变量名称相同的话，那么新定义的变量会覆盖前面的变量
    m.setb(100);
    cout << "setb" << m.getb() << endl;     //输出的是3，未改变类中的b
    m.setmm(100);
    cout << "setmm" << m.getb() << endl;   //输出100，因为改变了类中的b
    cout << m.add(1000) << endl;           //输出1004
    return 0;
}

结果如下：

successful
successful
Box1 successful
2
0
setb= 3
setmm= 100
1004

派生类的中对基类的访问有以下两种方式：
内部访问：派生类新增的成员函数对基类成员的访问，也就是说是函数访问;
对象访问：派生类的外部，对继承而来的成员进行直接访问。（例如住函数中的A.X）;

1.public 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：public, protected, private
2.protected 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：protected, protected, private
3.private 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：private, private, private

但无论哪种继承方式，上面两点都没有改变：
1.private 成员只能被本类成员（类内）和友元访问，不能被派生类访问；
2.protected 成员可以被派生类访问。

注意：新的继承类中含有基类相同的变量的时候，基类的变量相当于在继承类中重新定义（包括修饰符与具体属性）

公有继承：
公有继承是指继承方式是public，其访问的规则如下：

基类成员类型	public	protected	private
内部访问	可以访问	可以访问	不能访问
对象访问	可以访问	不能访问	不能访问

保护继承：
公有继承是指继承方式是protected，其访问的规则如下：

基类成员类型	public	protected	private
内部访问	可以访问	可以访问	不能访问
对象访问	不能访问	不能访问	不能访问

私有继承：
公有继承是指继承方式是private，其访问的规则如下：

基类成员类型	public	protected	private
内部访问	可以访问	可以访问	不能访问
对象访问	不能访问	不能访问	不能访问

C++中的构造函数与析构函数

C++中的构造函数定义的方法是名称与类的名称完全一致及classname();他在每次创建类的一个新对象的时候执行，其主要是用于初始化。继承的时候，当定义一个新的继承类，那么也会把前面的父类的继承函数中的构造函数去执行
例子：

#include <iostream>
using namespace std;
class Box
{
public:
    int a;
    int geta();
    int getb();
    int getc();
    Box();
protected:
    int b;
private:
    int c;
};
int Box::geta()
{
    return a;
}
int Box::getb()
{
    return b;
}
int Box::getc()
{
    return c;
}
Box::Box()
{
    a=1;
    b=2;
    c=3;
    cout << "Box successful" << endl;
}
//或者是执行一下部分
/*Box::Box():a(1),b(2),c(3)
{
    cout << "Box successful" << endl;
}*/
class Box1:public Box
{
public:
    int n;
    Box1();
};
Box1::Box1()
{
    cout << "Box1 successful" << endl;
}
int main()
{
    Box m;
    Box1 n,p,o;
    cout << n.n << endl;
    cout << m.a << endl << m.getb() << endl << m.getc() << endl;
    return 0; 
}

输出：

Box successful
Box successful
Box1 successful
Box successful
Box1 successful
Box successful
Box1 successful
0
1
2
3

如果相对初始化过程中赋值，那么代码如下

#include <iostream>
using namespace std;
class Box
{
public:
    int a;
    int geta();
    int getb();
    int getc();
    Box(int a1,int b1,int c1);
protected:
    int b;
private:
    int c;
};
int Box::geta()
{
    return a;
}
int Box::getb()
{
    return b;
}
int Box::getc()
{
    return c;
}
Box::Box(int a1,int b1,int c1)
{
    a=a1;
    b=b1;
    c=c1;
    cout << "Box successful" << endl;
}
//或者是
/*Box::Box(int a1,int b1,int c1):a(a1),b(b1),c(c1)
{
    cout << "Box successful" << endl;
}*/
int main()
{
    Box m(4,5,6);
    cout << m.a << endl << m.getb() << endl << m.getc() << endl;
    return 0; 
}

输出结果是：

Box successful
4
5
6

析构函数

类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。
析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。
下面的实例有助于更好地理解析构函数的概念：

#include <iostream>

using namespace std;

class Line
{
   public:
      void setLength( double len );
      double getLength( void );
      Line();   // 这是构造函数声明
      ~Line();  // 这是析构函数声明

   private:
      double length;
};

// 成员函数定义，包括构造函数
Line::Line(void)
{
    cout << "Object is being created" << endl;
}
Line::~Line(void)
{
    cout << "Object is being deleted" << endl;
}

void Line::setLength( double len )
{
    length = len;
}

double Line::getLength( void )
{
    return length;
}
// 程序的主函数
int main( )
{
   Line line;

   // 设置长度
   line.setLength(6.0); 
   cout << "Length of line : " << line.getLength() <<endl;

   return 0;
}

结果如下：

Object is being created
Length of line : 6
Object is being deleted

拷贝构造函数

拷贝构造函数主要是用于将已有的变量去初始化新的变量，常在以下三种情况使用：
- 通过使用另一个同类型的对象来初始化新创建的对象。
- 复制对象把它作为参数传递给函数。
- 复制对象，并从函数返回这个对象。
- 如果类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数。
拷贝构造函数的最常见形式如下：

classname (const classname &obj) {
   // 构造函数的主体
}

例子：

#include <iostream>
using namespace std;
class Box
{
public:
    int a;
    int geta();
    int getb();
    int getc();
    void seta(int a1);
    void setb(int b1);
    void setc(int c1);
    Box(int a1,int b1,int c1);
    Box(const Box &M);
    Box add1(Box x);
protected:
    int b;
private:
    int c;
};
int Box::geta()
{
    return a;
}
int Box::getb()
{
    return b;
}
int Box::getc()
{
    return c;
}
void Box::seta(int a1)
{
    a=a1;
}
void Box::setb(int b1)
{
    b=b1;
}
void Box::setc(int c1)
{
    c=c1;
}
Box::Box(int a1,int b1,int c1)
{
    a=a1;
    b=b1;
    c=c1;
    cout << "Box successful" << endl;
}
Box::Box(const Box &M)
{
    a=M.a;
    b=M.b;
    c=M.c;
}
Box Box::add1 (Box x)
{
    x.a=x.a+1;
    x.setb(x.getb()+1);
    x.setc(x.getc()+1);
    cout << "x4= "<< x.a << endl << x.getb() << endl << x.getc() << endl;
    return x;
}
/*Box::Box(int a1,int b1,int c1):a(a1),b(b1),c(c1)
{
    cout << "Box successful" << endl;
}*/
int main()
{
    Box m(4,5,6);
    Box n = m;
    cout << "m1= "<< m.a << endl << m.getb() << endl << m.getc() << endl;
    cout << "2= "<< n.a << endl << n.getb() << endl << n.getc() << endl;
    n=n.add1(n);
    cout << "n3= "<< n.a << endl << n.getb() << endl << n.getc() << endl;
    return 0; 
}

结果

Box successful
m1= 4
5
6
2= 4
5
6
x4= 5
6
7
n3= 5
6
7

有关拷贝函数的参考文档;

C++友元函数

友元函数的定义定义外类的外部，即前面没有”classname::”这样的存在，他能访问所有的修饰符修饰的变脸。只需要前面加上friend即可，如果在函数面前例如：

classs first
{
     ......
     friend void test(int a,int b);
}
void test (int a,int b)
{
...
}

例子

#include <iostream>

using namespace std;

class A
{
public:
    friend void set_show(int x, A &a);      //该函数是友元函数的声明
private:
    int data;
};

void set_show(int x, A &a)  //友元函数定义，为了访问类A中的成员
{
    a.data = x;
    cout << a.data << endl;
}
int main(void)
{
    class A a;

    set_show(1, a);

    return 0;
}

结果

如果是声明一个友元类，那么方式如下

classs first
{
     ......
     void test(int a,int b);
}
class second
{
    public：
    firend class first

}

例子：

#include <iostream>

using namespace std;

class A
{
public:
    friend class C;                         //这是友元类的声明
private:
    int data;
};

class C             //友元类定义，为了访问类A中的成员
{
public:
    void set_show(int x, A &a) { a.data = x; cout<<a.data<<endl;}
};

int main(void)
{
    class A a;
    class C c;

    c.set_show(1, a);

    return 0;
}

结果

内联函数

内联函数的关键字是inline，主要作用是在编译的过程中，将函数变为内联函数中的定义，一般不超过十行，并且不要有循环，switch等。
例子：

inline int add（int a,int b）
{
return a+b;
}

在函数中存在以下调用
result=add(a,b);
那么在编译的过程中就会替换成一下结果，
result=a+b;
主要作用是方便海量的修改，并且提高效率！

C++ this指针

this指针只能够在class的定义中使用，使用方法是this->
例子：

#include <iostream>
using namespace std;
class Box
{
public:
    Box(int a1,int b1,int c1);  //构造函数
    Box(const Box &obj);   //拷贝构造函数
    ~Box();                  //析构函数
    int compare(Box &box);    //&是指引用，能够降低开销，被引用的变量访问方式与其他别无区别，就相当于别名;
/*这里指变量的引用，并不是函数
（1）&在这里不是求地址运算，而是起标识作用。
（2）类型标识符是指目标变量的类型。
（3）声明引用时，必须同时对其进行初始化。
（4）引用声明完毕后，相当于目标变量名有两个名称，即该目标原名称和引用名，且不能再把该引用名作为其他变量名的别名。（函数可以一样）
（5）对引用求地址，就是对目标变量求地址。即引用名是目标变量名的一个别名。引用在定义上是说引用不占据任何内存空间，但是编译器在一般将其实现为const指针，即指向位置不可变的指针，所以引用实际上与一般指针同样占用内存。
（6）不能建立引用的数组。因为数组是一个由若干个元素所组成的集合，所以无法建立一个由引用组成的集合，但是可以建立数组的引用。
（7）引用常见的使用用途：作为函数的参数、函数的返回值。*/
private:
    int a;
    int b;
    int c;
};
Box::Box(int a1,int b1,int c1)
{
    a=a1;
    b=b1;
    c=c1;
}
Box::Box(const Box &obj)
{
    a=obj.a;
    b=obj.b;
    c=obj.c;
}
Box::~Box()
{
    ;
}
int Box::compare(Box &box){
    box.a=box.a-1;
    return (this->a)*(this->b)*(this->c)>(box.a)*(box.b)*(box.c);
}
int main()
{
    Box box(1,2,3);
    Box box1=box;
    if(box.compare(box1))
        cout << ">" <<endl;
    else
        cout << "<=" << endl;
    return 0;
}

结果是

const 关键字

详见一下网站：http://www.cnblogs.com/yc_sunniwell/archive/2010/07/14/1777416.html
总结：
对于常量：const的位置的右边表示那个不能变，例如const int a=10,表示的是不能通过a修改a代表的数，但是可以通过算出a的地址，使用a的地址来更a代表区域的值。如果使用了以下代码int *aa=(int *)&a; (*aa)=10; cout << "a= " << a <<endl;那么输出的a仍然是10;非指针情况下一定要在声明的时候赋值，否则默认是0。函数中变量同样遵循次规则寄int char（int const a）表示函数中不能更改a的值。可以搜索常量折叠来弄清输出都是1111的问题

对于指针：const inti * P,表示(P)的内容是不可更改的，P叫做变量指针。int const P 表示P本身的这个地址是不可修改的P叫做指针常量（不能通过P来修改地址或者地址指向的内容，可以将地址转换成其他字符）。
对于引用：

     nt i = 10;

    // 正确：表示不能通过该引用去修改对应的内存的内容。

    const int& ri = i;

    // 错误！不能这样写。

    int& const rci = i;

与常量是一致的

例子：

#include <iostream>  
using namespace std;  

class CExample   
{  
private:  
 int a;  

public:  
 //构造函数  
 CExample(int b)  
 {   
  a = b;  
  cout<<"creat: "<<a<<endl;  
 }  

 //拷贝构造  
 CExample(const CExample& C)  
 {  
  a = C.a;  
  cout<<"copy"<<endl;  
 }  

 //析构函数  
 ~CExample()  
 {  
  cout<< "delete: "<<a<<endl;  
 }  

     void Show ()  
 {  
         cout<<a<<endl;  
     }  
};  
 int test1 (const int a)
 {
    //a=10;               //fail
     int *aa=(int *)&a;
     (*aa)=1000;
    return a;
 } 
//全局函数，传入的是对象  
void g_Fun(CExample C)  
{  
 cout<<"test"<<endl;  
}  

int main()  
{  
 CExample test(1);  
 //传入对象  
 g_Fun(test); 
 const int a=1;
 int *aa=(int *)&a;
 (*aa)=10;
 cout << "a= " << a <<endl;
 (*aa)=test1(100);
  cout << "a= " << a <<endl;
 int *q=new int ();
 cout << "q=" << q <<endl; 
 int * const p=new int();
 //int *q=(int *)p; 
 cout << "p=" << p <<endl; 
  int **w=(int**)&p;
  *w=(int *)q;
  cout << "p=" << p <<endl; 

  int Q=10;
 const int * P=&Q;
 //int *q=(int *)p; 
 cout << "P=" << *P <<endl; 
int *W=(int *)P;
*W=100;
cout << "P=" << *P <<endl; 

 return 0;  
}

结果：

creat: 1
copy
test
delete: 1
a= 1
a= 1
q=0x1f6b030
p=0x1f6b050
p=0x1f6b030
P=10
P=100
delete: 1

（class内）常量函数：一个函数的签名后面加上关键字const后该函数就成了常量函数。对于常量函数，最关键的不同是编译器不允许其修改类的数据成员
例子：

class Test

    {

    public:

    void func() const;

    private:

    int intValue;

    };

    void Test::func() const

    {

    intValue = 100;  //不允许

    }

当然，对于非常量的成员函数，我们可以根据需要读取或修改数据成员的值。但是，这要依赖调用函数的对象是否是常量。通常，如果我们把一个类定义为常量，我们的本意是希望他的状态（数据成员）不会被改变。那么，如果一个常量的对象调用它的非常量函数会产生什么后果呢？看下面的代码：


    class Fred{

    public:

    void inspect() const;    //加上const，表示不希望修改变量

    void mutate();

    };

    void UserCode(Fred& changeable, const Fred& unChangeable)  //加上const表示不希望改unChangeable的值，因此智能调用const函数
    {

    changeable.inspect(); // 正确，非常量对象可以调用常量函数。

    changeable.mutate(); // 正确，非常量对象也允许修改调用非常量成员函数修改数据成员。

    unChangeable.inspect(); // 正确，常量对象只能调用常理函数。因为不希望修改对象状态。

    unChangeable.mutate(); // 错误！常量对象的状态不能被修改，而非常量函数存在修改对象状态的可能

    }

常量返回值：
const 修饰类的数据成员。如：
class A
{

const int size;

…

}

const数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的。因为类可以创建多个对象，不同的对象其const数据成员的值可以不同。所以不能在类声明中初始化const数据成员，因为类的对象未被创建时，编译器不知道const 数据成员的值是什么。如

class A

{

 const int size = 100;    //错误

 int array[size];         //错误，未知的size

}

如果给采用“指针传递”方式的函数返回值加const修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const 修饰的同类型指针。如：

const char * GetString(void);

如下语句将出现编译错误：

char *str=GetString();

正确的用法是：

const char *str=GetString();

注意：用const修饰函数返回值的含义和用const修饰普通变量以及指针的含义基本相同。

总结http://www.cnblogs.com/chogen/p/4574118.html
例子：

#include <iostream>  
using namespace std; 
static int m=999 ;
static int *add=&m;
class CExample   
{  
private:  
 int a;  

public:  
 //构造函数  
 CExample(int b)  
 {   
  a = b;  
  cout<<"creat: "<<a<<endl;  
 }  

 //拷贝构造  
 CExample(const CExample& C)  
 {  
  a = C.a;  
  cout<<"copy"<<endl;  
 }  

 //析构函数  
 ~CExample()  
 {  
  cout<< "delete: "<<a<<endl;  
 }  

     void Show ()  
 {  
         cout<<a<<endl;  
     }  
};  
 const int test1 (int a)
 {
    //a=10;               //fail

    return a+1;
 }
  const int *test2 ()
 {
    //a=10;               //fail

    return add;
 }
 int * const test3 ()
 {
    //a=10;               //fail

    return add;
 } 
//全局函数，传入的是对象  
void g_Fun(CExample C)  
{  
 cout<<"test"<<endl;  
}  

int main()  
{  
 CExample test(1);  
 //传入对象  
 g_Fun(test); 
int p=1;
const int *q,*n;    //如果不加上const的话那么
p=test1(99);
p++;
q=test2();
n=test3();
n=&p;
cout << "=" << *q << endl; 

 return 0;  
}

结果

creat: 1
copy
test
delete: 1
=999
delete: 1

static

参考网址：http://blog.csdn.net/majianfei1023/article/details/45290467
静态变量都在全局数据区分配内存，包括后面将要提到的静态局部变量。对于一个完整的程序，在内存中的分布情况如下图：

代码区
全局数据区
堆区
栈区

一般程序的由new产生的动态数据存放在堆区，函数内部的自动变量存放在栈区。自动变量一般会随着函数的退出而释放空间，静态数据（即使是函数内部的静态局部变量）也存放在全局数据区。全局数据区的数据并不会因为函数的退出而释放空间。
静态局部变量：
在子函数内声明，第一次调用子函数的时候被初始化，当函数被调用的时候，就开始存在，当函数被再次调用的时候，static变量仍然是上一次的数值，不会随着子函数的消失而消失。
例子

#include <iostream>
using namespace std;
int test()
{
    static int a;
    a++;
    return a;
}
int main()
{
    int a=10;
    cout << "a= " << a << endl;
    test();
    cout << "a= " << a << endl;
    a=test();
    cout << "a= " << a << endl;
    return 0;
}

结果：

a= 10
a= 10
a= 2

静态全局变量：主要是让文件中的变量只能够在本文件中使用，再多个文件共同编译的时候，能够防止文件中的变量被其他文件使用。
例子：

文件1是上述文件
文件2:
static int b=10;

编译的过程中会出现以下问题：

/tmp/ccf95Eke.o：在函数‘main’中：
static.cpp:(.text+0xbe)：对‘b’未定义的引用
collect2: error: ld returned 1 exit status

如果将static去掉，那么编译成功！

静态函数：与静态全局变量类似，当一个文件用static定义一个函数A，另外一个也可以定义一个函数A，这样编译不会报错，但是如果把static去掉就会报错，重复定义。

静态数据成员：一个class类只有一个静态数据成员，并且要在class外部使用
变量类型类的名称：：变量名称=初始值;
的方式进行初始化.
每个类的初始化一定要在class类之外。

静态函数成员：静态函数成员主要是在函数面前添加static：
他有一下规则：
1.静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数;
2.非静态成员函数可以任意地访问静态成员函数和静态数据成员;
3.静态成员函数不能访问非静态成员函数和非静态数据成员;
4.调用静态成员函数，可以用成员访问操作符(.)和(->)为一个类的对象或指向类对象的指针调用静态成员函数,也可以用类名::函数名调用(因为他本来就是属于类的，用类名调用很正常)

总结起来就是静态成员函数只能够访问静态成员函数与静态数据成员，非静态成员函数是两个都能够访问。

daichunkai123

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C++学习笔记（2）-类

C++中的类类的定义使用class表示，他的格式如下：calss classname { public：变量类型1 变量名称1; 变量类型2 变量名称2; 变量类型3 变量名称3; };则在后续的使用的过程中，其结构如下： classname a1; classname a2; 例子如下：#include <iostream>using namespace std;
复制链接

扫一扫