Jiancong Li's Blog

class A
{
};

int main()
{
    A obj;          ///< 调用构造函数
    A* p = new A;   ///< 调用构造函数
}

int main()
{
    {
        A obj;
    }   ///< 临时变量超出作用域，调用析构函数

    A* p = new A;
    delete p;   ///< 调用析构函数
}

GJSON*  gos_json_init(void);
void    gos_json_free(GJSON* Json);
bool    gos_json_parse(GJSON* Json, char *szJson);
char*   gos_json_get_string (GJSON* Json, char *szKey);

int main()
{
    GJSON* pJson = gos_json_init();
    gos_json_parse(pJson, "Json string");
    char* szValue = gos_json_get_string(pJson, "Key");
    ...
    gos_json_free(pJson);
}

class Json
{
public:
    bool    parse(char *szJson);
    char*   get_string (char *szKey);

private:
    GJSON* m_Json;
};

int main()
{
    Json obj;
    obj.parser("Json string");
    char* szValue = obj.get_string("Key");
}

class Json
{
public:
    /// 构造函数
    Json()
    {
        m_Json = init();
    }

    /// 析构函数
    ~Json()
    {
        free(m_Json);
    }

    bool    parse(char *szJson);
    char*   get_string (char*szKey);

private:
    GJSON* m_Json;
    GJSON* init();
    void free(GJSON* Json);
};

unsigned g_ulLogLevel;
bool     g_bLogToStdout;
bool     g_bLogToFile;

void GetLogCfg()
{
    /// 给变量赋值
    g_ulLogLevel = 1;
    g_bLogToStdout = TRUE;
    g_bLogToFile = TRUE;
}

/// 在其他 cpp 文件中访问这些配置项
extern unsigned g_ulLogLevel;
extern bool     g_bLogToStdout;
extern bool     g_bLogToFile;

class LocalCfg
{
public:
    LocalCfg() { GetLogCfg(); }

    unsigned m_ulLogLevel;
    bool     m_bLogToStdout;
    bool     m_bLogToFile;

private:
    void GetLogCfg();
};

/// 在其他地方访问这些配置项
int main()
{
    LogCfg obj;

    obj.m_ulLogLevel;
    obj.m_bLogToStdout;
    obj.m_bLogToFile;
}

class LocalCfg
{
public:
    void Set(int i) { value = i; }
    int Get() { return value; }
private:
    int value;
};

class LocalCfg
{
public:
    void Set(int i)
    {
        GosLog(LOG_DETAIL, "value: %d -> %d", value, i);
        value = i;
    }
    int Get() { return value; }
private:
    int value;
};

class LocalCfg
{
public:
    void Set(int i)
    {
        mutex.lock();
        value = i;
        mutex.unlock();
    }

    int Get()
    {
        mutex.lock();
        int value_temp = value;
        mutex.unlock();
        return value_temp;
    }

private:
    int value;
    GMutex mutex;
};

class LocalCfg
{
public:
    void Set(int i)
    {
        value = i;
        IsSet = true;
    }

    int Get()
    {
        if (IsSet)
        {
            return value;
        }
        else
        {
            /// 返回无效值
            return -1;
        }
    }

private:
    int value;
    // 用于记录 value 是否有效
    bool IsSet = false;
};

class A
{
public:
    /// 把大象放进冰箱里
    bool PutElephantInFreezer()
    {
        /// 打开冰箱门
        OpenFreezerDoor();
        /// 把大象放进去
        LetElephantIn();
        /// 关上冰箱门
        CloseFreezerDoor();
    }

private:
    void OpenFreezerDoor();
    void LetElephantIn();
    void CloseFreezerDoor();
};

int main()
{
    A obj;
    // 调用 public 函数来把大象放进冰箱里
    obj.PutElephantInFreezer();
}

class OBJECT
{
public:
    int i_public;
private:
    int i_private;
};

int main()
{
    // 对象实例化
    OBJECT obj;

    // 对象实例访问 public 类成员
    obj.i_public = 1;

    // 对象实例无法访问 private 成员
    // obj.i_private = 1;
}

class A
{
    friend void Set(A& obj, int num);
private:
    int i_private;
};

/// 友元函数不属于某个类，所以定义时
/// 不需要这样写:
/// void count::Set(counter& obj, int num)
void Set(A& obj, int num)
{
    /// 友元函数内，对象实例访问对象私有成员
    obj.i_private = num;
}

class B;

class A
{
    friend void Set(A& obja, B& objb, int num);
private:
    int i_private;
};

class B
{
    friend void Set(A& obja, B& objb, int num);
private:
    int i_private;
};

void Set(A& obja, B& objb, int num)
{
    obja.i_private = num;
    objb.i_private = num;
}

int main()
{
    A obj_a;
    B obj_b;
    Set(obj_a, obj_b, 1);
    return 0;
}

class A
{
public:
    static int counter = 0; ///< 记录对象被实例化了多少次
    A(){count++;}
};

int main()
{
    A obj;
    std::cout << A::counter << std::endl;
}

class A
{
public:
    static int counter;
    static int GetCounter()
    {
        return counter;
    }

public:
    int i_non_static = 0;
    int fun_non_static()
    {
        printf("Hello World!");
    }
};

int A::counter = 0;

int main()
{
    A obj0;
    A obj1;
    printf("%d", A::GetCounter());
    printf("%d", obj0.GetCounter());
    printf("%d", obj1.GetCounter());
    return 0;
}

class Singleton
{
public:
    static Singleton& GetInstance()
    {
        static Singleon* pInstance = NULL;
        if(pInstance == NULL)
        {
            pInstance = new Singleon;
        }
        return *pInstance;
    }

private:
    Singleon() {}
};

class base
{
public:
    base() : strBusinessID(gos::GetUUID()) {}
public:
    std::string strBusinessID;
};

/// 点呼从基类中继承出来了一个业务 ID
class P2PCall : public base
{};

int main()
{
    P2PCall p2p_call;   ///< 自动生成了一个唯一的业务号

    std::cout << p2p_call.strBusinessID << std::endl;
}

class base
{
    virtual ~base(){ std::cout << "~base" << std::endl; }
};

class derive: public base
{
    virtual ~derive() { std::cout << "~derive" << std::endl; } ///< 不定义虚析构函数会导致内存泄漏
};

int main()
{
    base* p = new derive;
    delete p;
}

class base
{
private:
  int i_private;
protected:
  int i_protected;
};

class derive : public base
{
public:
  int get_protected()
  {
    // 可访问基类中的 protected 成员
    return i_protected;
  }

  // int get_private()
  // {
  //   基类中的 private 成员不能被派生类访问
  //   return i_private;
  // }
};

int main()
{
  base obj0;
  // 在基类实例中表现为私有成员, 不可访问
  // obj0.i_protected = 0;
  derive obj;
  // 在派生类实例中表现为私有成员, 不可访问
  // obj.i_protected = 0;
  return 0;
}

class VSCode
{
public:
    void UseVSCode();
};

class SourceInsight
{
public:
    void UseSourceInsight();
};

// class Programmer 拥有了 class VSCode 和
// class SourceInsight 中的方法函数
class Programmer : public VSCode, public SourceInsight
{
};

int main()
{
    Programmer lijiancong;
    lijiancong.UseVSCode();
    lijiancong.UserSourceInsight();
}

class A
{
protected:
  int i_protected;
};

class B
{
protected:
  int i_protected;
};

class Derive : public A, public B
{
public:
  int get()
  {
    /// 如果两个基类中拥有同名成员变量或函数，
    /// 派生类使用时应该标注哪个类的成员变量或函数， 否则编译错误
    return A::i_protected;
  }
};

class Tool
{
public:
  Tool()
  {
    std::cout << "Tool::i: " << &i
              << std::endl;
  }
protected:
  int i = 1;
};

class VSCode : public Tool
{
public:
  VSCode()
  {
    std::cout << "VSCode::i: " << &(VSCode::i)
              << std::endl;
  }
};

class SourceInsight : public Tool
{
public:
  SourceInsight()
  {
    std::cout << "SourceInsight::i: "
              << &(SourceInsight::i)
              << std::endl;
  }
};

class Programmer : public VSCode, public SourceInsight
{
};

int main()
{
    Programmer lijiancong;
    return 0;
}

class Tool
{
protected:
  int i;
};

///  使用 `virtual` 关键字来避免菱形继承
class VSCode : virtual public Tool
{
};

///  使用 `virtual` 关键字来避免菱形继承
class SourceInsight : virtual public Tool
{
};

class Programmer : public VSCode, public SourceInsight
{
public:
  int get()
  {
    return i; ///< 正常使用 Tool 类中的函数
  }
};

int main()
{
    Programmer lijiancong;
    lijiancong.get();
}

class base
{
public:
  int i_public;
protected:
  int i_protected;
private:
  int i_private;
};

/// public 继承
class derive : public base
{
public:
  void get()
  {
    i_public = 0;       ///< 基类中 `public` 成员， 在派生类中表现为 `public`
    i_protected = 0;    ///< 基类中 `protected` 成员，在派生类中表现为 `protected`
    /// i_private = 0;  ///< 基类中 `private` 成员，在派生类中不可访问
  }
};

int main()
{
    derive obj;
    obj.i_public = 0;
    /// obj.i_protected = 0;  不可访问
    /// obj.i_private = 0;  不可访问
    return 0;
}

class derive : protected base
{
public:
  void get()
  {
    i_public = 0;       ///< 基类中 `public` 成员， 在派生类中表现为 `protected`
    i_protected = 0;    ///< 基类中 `protected` 成员，在派生类中表现为 `protected`
    /// i_private = 0;  ///< 基类中 `private` 成员，在派生类中不可访问
  }
};

class derive0 : public derive
{
  void get0()
  {
    i_public = 0;
    i_protected = 0;
    /// i_private = 0;
  }
};

int main()
{
    derive0 obj;
    obj.get();
    /// obj.i_public = 0;     不可访问
    /// obj.i_protected = 0;  不可访问
    /// obj.i_private = 0;    不可访问
    return 0;
}

class derive : private base
{
public:
  void get()
  {
    i_public = 0;       ///< 基类中 `public` 成员， 在派生类中表现为 `private`
    i_protected = 0;    ///< 基类中 `protected` 成员，在派生类中表现为 `private`
    /// i_private = 0;  ///< 基类中 `private` 成员，在派生类中不可访问
  }
};

class derive0 : public derive
{
  void get0()
  {
    /// i_public = 0;
    /// i_protected = 0;
    /// i_private = 0;
  }
};

int main()
{
    derive0 obj;
    obj.get();
    /// obj.i_public = 0;     不可访问
    /// obj.i_protected = 0;  不可访问
    /// obj.i_private = 0;    不可访问
    return 0;
}

class Interface
{
public:
    virtual void Insert() = 0;
    virtual void Query() = 0;
};

class MySqlImpl : public Interface
{
public:
    virtual void Insert()
    {
        MySql_Insert();
    }

    virtual void Query()
    {
        MySql_Query();
    }
};

class RedisImpl : public Interface
{
public:
    virtual void Insert()
    {
        Redis_Insert();
    }

    virtual void Query()
    {
        Redis_Query();
    }
};

class Factory
{
public:
    static Interface* getInterface(bool bIsUseMySQL)
    {
        if(bIsUseMySQL)
        {
            p = new MySqlImpl();
        }
        else
        {
            p = new RedisImpl();
        }
    }
};

int main()
{
    Factory factory;
    Interface* p = factory.GetInterface(true);
    // 通过基类指针指向派生类
    // 调用基类中的虚函数，会通过编译器自动识别
    // 是使用 MySQL 的实现还是 Redis 的实现
    p->Insert();
    p->Query();
}

class Interface
{
public:
      virtual void Insert(int i) { std::cout << "Interface::Insert" << std::endl; }
};

class MySqlImpl : public Interface
{
public:
    ///  这里没有使用多态对基类中的 `Insert` 函数进行覆盖(override), 而是单独创建了一个新的虚函数
    virtual void Insert(std::string s) { std::cout << "MySQL::Insert" << std::endl; }
};

class RedisImpl : public Interface
{
public:
    virtual void Insert(int d) { std::cout << "RedisImpl::Insert" << std::endl; }
};

int main()
{
  Interface* pRedis = new RedisImpl;
  pRedis->Insert(1);  ///< 正常使用多态，访问派生类的 `Insert` 函数的实现

  Interface* pMySQL = new MySqlImpl;
  /// pMySQL->Insert("Hello World!"); 无法使用基类指针访问多态函数 `Insert`
  pMySQL->Insert(1);  ///< 只能访问基类 `Insert` 函数的实现
  return 0;
}

class Interface
{
    public:
      virtual void Insert(int i) { std::cout << "Interface::Insert" << std::endl; }
};

class MySqlImpl : public Interface
{
public:
    /// 由于 `override` 要求必须该函数对基类函数进行覆盖，这里由于入参不一致, 会出现编译错误
    virtual void Insert(std::string s) override { std::cout << "MySQL::Insert" << std::endl; }
};

class a
{
public:
    a(): y(0), x(y+1) {}
    int x;
    int y;
};

int main()
{
    a obj;
    std::cout << "x: " << obj.x << ", y: " << obj.y;
    return 0;
}

SELECT DCUserID, GroupID, Time, CallType FROM groupcallinfo WHERE DCUserID BETWEEN 13003 AND 13005;
SELECT DCUserID, GroupID, Time, CallType FROM groupcallinfo WHERE DCUserID >= 13003 AND DCUserID <= 13005;

#include <iostream>

int main()
{
    std::cout << "---标准类型大小---" << std::endl;
    std::cout << "short size:              " << sizeof(short) << std::endl;
    std::cout << "int size:                " << sizeof(int) << std::endl;
    std::cout << "unsigned int size:       " << sizeof(unsigned int) << std::endl;
    std::cout << "long size:               " << sizeof(long) << std::endl;
    std::cout << "unsigned long size:      " << sizeof(unsigned long) << std::endl;
    std::cout << "long long size:          " << sizeof(long long) << std::endl;
    std::cout << "unsigned long long size: " << sizeof(unsigned long long) << std::endl;
    std::cout << "size_t size:             " << sizeof(size_t) << std::endl;
    std::cout << "double size:             " << sizeof(double) << std::endl;
    std::cout << "float size:              " << sizeof(float) << std::endl;
    std::cout << "char size:               " << sizeof(char) << std::endl;
    std::cout << "unsigned char size:      " << sizeof(unsigned char) << std::endl;
    std::cout << "signed char size:        " << sizeof(signed char) << std::endl;
    std::cout << "pointer size:            " << sizeof(void*) << std::endl;

    std::cout << std::endl;
    std::cout << "---自定义类型大小---" << std::endl;
    std::cout << "SHORT(short) size:               " << sizeof(short) << std::endl;
    std::cout << "INT(int) size:                   " << sizeof(int) << std::endl;
    std::cout << "LONG(long) size:                 " << sizeof(long) << std::endl;
    std::cout << "UINT8(unsigned char) size:       " << sizeof(unsigned char) << std::endl;
    std::cout << "UINT16(unsigned short) size:     " << sizeof(unsigned short) << std::endl;
    std::cout << "UINT32(unsigned int) size:       " << sizeof(unsigned int) << std::endl;
    std::cout << "UINT64(unsigned long long) size: " << sizeof(unsigned long long) << std::endl;
    std::cout << "INT8(char) size:                 " << sizeof(char) << std::endl;
    std::cout << "INT16(short) size:               " << sizeof(short) << std::endl;
    std::cout << "INT32(int) size:                 " << sizeof(int) << std::endl;
    std::cout << "INT64(long long) size:           " << sizeof(long long) << std::endl;
    std::cout << "FLOAT(float) size:               " << sizeof(float) << std::endl;
    std::cout << "DOUBLE(double) size:             " << sizeof(double) << std::endl;
    std::cout << "CHAR(char) size:                 " << sizeof(char) << std::endl;
    std::cout << "BOOL(int) size:                  " << sizeof(int) << std::endl;
    std::cout << "BYTE(unsigned char) size:        " << sizeof(unsigned char) << std::endl;
    std::cout << "HANDLE(void*) size:              " << sizeof(void*) << std::endl;

    return 0;
}

int index = 0;
for(int i = 0; i < 10; ++i)
{
    /// do something with index
}

for(int i = 0; i < 10; ++i)
{
    int index = 0;
    /// do something with index
}

temp = Sqrt(b*b - 4*a*c);
root[0] = (-b + temp) / (2*a);
root[1] = (-b - temp) / (2*a);

// swap the roots
temp = root[0];
root[0] = root[1];
root[1] = temp;

discriminant = Sqrt(b*b - 4*a*c);
root[0] = (-b + discriminant) / (2*a);
root[1] = (-b - discriminant) / (2*a);

// swap the roots
oldRoot = root[0];
root[0] = root[1];
root[1] = oldRoot;

x = x - xx;
xxx = fido + SalesTax(fido);
x = x + LateFee(x1, x) + xxx;
x = x + Interest(x1, x);

balance = balance - lastPayment;
monthlyTotal = newPurchases + SalesTax(newPurchases);
balance = balance + LateFee(customerID, balance) + monthlyTotal;
balance = balance + Interest(customerID, balance);

if (flag) ...
if (statusFlag & 0xF) ...
if (printFlag == 16) ...
if (computeFlag == 0) ...

if (dataReady) ...
if (characterType & PRINTABLE_CHAR) ...
if (reportType == ReportType_Annual) ...
if (recalcNeeded == false) ...

AnsiString strTmp;
strTmp = edtAccount->Text;
if(strTmp.IsInvalid())
{
    st.Account = strTmp;
}
strTmp = edtPassword->Text;
if(strTmp.IsInvalid())
{
    st.Password = strTmp;
}

#include <iostream>

int main()
{
    double d = 100000000.0 + 0.1;
    std::cout << d << std::endl;
    return 0;
}

#include <iostream>

int main()
{
    double tmp = 0.0;
    for(int i = 0; i < 10; ++i)
    {
        tmp += 0.1;
        std::cout << tmp << std::endl;
    }
    return 0;
}

int a = 0;
int b = 0;
bool IncreaseA()
{
    a++;
    return false;
}
bool IncreaseB()
{
    b++;
    return true;
}

int main(int argc, char* argv[])
{
    if(!IncreaseA() || !IncreaseB())
    {
    }
}

while(recordArray.Read(index++) != recordArray.EmptyRecord())
{
    ;
}

#define DoNothing()
while(...)
{
    DoNothing();
}

class A
{
public:
    /// 拷贝构造函数
    A(const A& other)
    {
        i = other.i;
        vec = other.vec;
    }

    /// 拷贝赋值符
    A& operator=(const A& other)
    {
        if(this != &other)
        {
            i = other.i;
            vec = other.vec;
        }
        return *this;
    }
private:
    int i;
    std::vector<int> vec;
};

A foo;
A bar(foo); ///< 在这里调用拷贝构造函数
A bar2;
bar2 = foo; ///< 这里调用拷贝赋值符

class pod
{
  char ac[12];
  int i;
  float f;
  long l;
};