C++ 关于static variables的学习中遇到的问题总结

类的数据成员可以修饰为静态的。 一个静态成员有如下特点：

（1）静态成员不属于对象， 属于类。 利用该类创建的对象共享这个数据成员。 或者说， 静态数据成员属于类， 而非对象的。 其他的普通的数据成员不同。 我们每一次利用这个类创建对象， 都有属于创建的对象的数据私有的成员。 函数是所有的对象的共享的。 在C++ 的最新标准C++11 中， 只有const static 的变量可以在class内部初始化（class 的definition 一般位于.h 头文件中）， 非const 的静态的数据变量只能够在class外部进行初始化， 一般放置在相关接口函数的implementations的.cpp
文件中。

（2）无论创建多少个对象 ， 都有一份static variable。

（2）静态成员的生存期是整个程序的执行期。

静态成员一般用于维护整个类的通用值。 比如某个静态数据变量可以作为计数器， 用于记录类对象的声明的个数。



举个bank account例子：

bank.h:

#ifndef BANK_H
#define BANK_H

#include <iostream>
#include <string>
using namespace std;

class Bank {
   public:
      //default constructor
      Bank();
      //overload constructor
      Bank(string, int, double);

      //destructor
      ~Bank();

      //accessor function
      string getName() const;
      int getAccountNumber() const;
      double getBalance() const;

      //mutator functions
      void setName(string);
      void setAccountNumber(int);
      void setBalance(double);

      void deposit(double);
      void withdraw(double);

      static void printBankInfo();

   private:
   //member variables
      string name;
      int accountNumber;
      double balance;

      static int totalAccount ;// must initialize in the implementation file, ie outside the class definition 
      static double bankBalance;

};

#endif

如果上图中， 在class内部中对static variable初始化，l例如： static int totalAccount = 0 ； 会出现如下报错。


所以改回来。

bank.cpp文件：

#include "Bank.h"
// static member variables
double Bank::bankBalance = 0;
int Bank::totalAccount = 10000;
Bank::Bank() {
    accountNumber = 0;
    balance = 0.0;
    totalAccount++;
}

Bank::Bank(string newName, int newAccount, double newBalance) {
    string name = newName;
    accountNumber = newAccount;
    balance = newBalance;
    totalAccount++;
    bankBalance += newBalance;
}

Bank::~Bank() {
    totalAccount--;
    bankBalance -= balance;
}

string Bank::getName() const {
   return name;
}
int Bank::getAccountNumber() const {
   return accountNumber;
}
double Bank::getBalance() const {
   return balance;
}

//mutator functions
void Bank::setName(string newName) {
   name = newName;
}
void Bank::setAccountNumber(int newAccountNumber) {
   accountNumber = newAccountNumber;
}
void Bank::setBalance(double newBalance) {
   bankBalance -= balance;
   balance = newBalance;
   bankBalance += balance;
}

void Bank::deposit(double amount) {
   balance += amount;
   bankBalance += amount;

}
void Bank::withdraw(double amount) {
   balance -= amount;
   bankBalance += amount;

}

void Bank::printBankInfo() {
   cout << endl << "Number of accounts: " << totalAccount << endl;
   cout << "total balance: " << bankBalance << endl;
}

注意上面， 虽然在bank.h 中静态变量和静态函数的声明中均使用了关键字static， 但是在bank.cpp 的实现文件中， 并没有用static 关键字。

如果我们在这个bank.cpp 中使用了static 关键字， 例如：static double Bank::bankBalance = 0; 出现错误如下：



所以改回来。

主程序main.cpp 文件如下：

#include <iostream>
#include <string>
#include "Bank.h"

using namespace std;

int main()
{
    Bank::printBankInfo();

    cout << "Adam create an account and deposit 500";
    Bank Adam("Adam", 0001, 500);
    Bank Sarah;
    cout << endl << "Sarah create an account and deposit 1000";
    Sarah.setName("Sarah");
    Sarah.setAccountNumber(0002);
    Sarah.setBalance(1000);

    Bank::printBankInfo();

    cout << "Dick creates an account and deposits 1500";
    Bank Dick("Dick", 0003, 1500);

    Bank::printBankInfo();

    cout << endl << "Dick set his balance to 1200";
    Dick.setBalance(1200);

    Bank::printBankInfo();

    cout << endl << "Sarah deposited 700";
    Sarah.deposit(700);
    Bank::printBankInfo();

    cout << "Adam's account was terminated due to lack of use.";
    Adam.~Bank();

    Bank::printBankInfo();

    return 0;
}

运行结果如下：



下面说说静态成员函数。

静态成员函数有如下特点：

（1）静态成员函数只能访问类中声明的其他静态成员（即静态成员函数和静态成员变量）。

（2）调用静态成员函数的时候， 使用的是类名(虽然也可以使用对象点运算的形式， 因为是该类所有的对象共享的， 所以当然也可以使用对象。 只不过用类名界符号定更加常见）