小编Tej*_*dra的帖子

我有下面的课:

class Cdata12Mnt
{
public:
    char IOBname[ID1_IOB_PIOTSUP-ID1_IOB_TOP][BOADNAM_MAX + 4];
    char ExIOBname[ID1_MAX_INF-ID1_EXIOB_U1TOP][BOADNAM_MAX + 4];
    char cflpath[256];
    char basetext[256];
    UINT database[ID1_MAX_INF];
    int State;

public:
    char SelectPath[256];

public:
    int GetIOBName(int slt,char *Name);
    Cdata12Mnt(char *SelectPath);
    virtual ~Cdata12Mnt();
    int     GetValue(int id);
    int     GetState() { return State; }
};

我的功能如下:

Cdata12Mnt::Cdata12Mnt(char *SelectPath)
{
    SCTReg  reg;
    char    buf[256], *cpnt, *npnt, *bpnt1, *bpnt2;
    char    *startcode[] = {"CNTL_CODE ","SEGMENT "};
    char    *stopcode    = {"END_CNTL_CODE "};
    FILE    *fp;
    int     ii, infl;

    State = 0;

    for (ii = 0; ii < …

根据ISO C++ Commitee的最后一次会议,将在C++ 20标准中引入bit-cast.

我知道reinterpret_cast由于类型合规规则不适合这项工作,但我的问题是为什么他们选择不延伸reinterpret_cast处理对象,比如它的位序列表示,并且更倾向于将此功能作为一种新的语言结构？

我们可以在函数内定义类/结构.我们还可以在函数内定义枚举和联合吗？

void fun() {
    enum {BIG, MID, SMALL};
    // other code.
}

我可以使用gcc 4.8.2编译代码,但我不确定它是否合法.

我知道,我们可以调用构造函数并重的理念Explicitly,并Implicitly和我已经测试这两种方案(通常到现在我所有的目的得到了通过调用构造函数实现Implicitlly),但我想知道,每当我们创建一个构造函数得到隐式调用objects,,等什么是调用构造函数的主要原因Explicitly.它提供了什么优势或劣势,当我们调用构造Explicitly过Implicit Call？

例

class integer
{
   int m ,n;
 public:
   integer (int x , int y); 
};
integer :: integer (int x , int y )
{
   m=x; n = y;
}

现在如果我打电话的话

integer int1 = integer( 0 , 100); //  Explicit Call
integer int1(1,100); // implicit call

Class A {
public:
       A(int i = 0, int k = 0) {} // default constructor WHY ??
       ~A() {}
};
int main()
{
  A a; // This creates object using defined default 
       // constructor but the constructor still has two arguments
  A b(1,2); // Called as parametrized one
}

为什么这个默认参数构造函数是默认构造函数.为什么它不被称为参数化构造函数或默认参数化构造函数,因为即使这个构造函数被调用而没有参数,它确实包含两个参数？是否有任何具体原因或仅仅因为标准这样说.

我正在阅读mongo资源代码，正在阅读using ::std::mutex，但我不知道这是什么意思？

namespace stdx {

using ::std::mutex;            // NOLINT
using ::std::timed_mutex;      // NOLINT
using ::std::recursive_mutex;  // NOLINT

using ::std::adopt_lock_t;   // NOLINT
using ::std::defer_lock_t;   // NOLINT
using ::std::try_to_lock_t;  // NOLINT

using ::std::lock_guard;   // NOLINT
using ::std::unique_lock;  // NOLINT

}

我在 python 日志类中观察到这个奇怪的问题，我有两个脚本，一个是从另一个脚本调用的。第一个脚本等待其他脚本结束，而其他脚本使用记录一个巨大的日志logging.info

这是代码片段

#!/usr/bin/env python

import subprocess
import time
import sys

chars = ["/","-","\\","|"]
i = 0
command = 'sudo python /home/tejto/test/writeIssue.py'
process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
while process.poll() is None:
    print chars[i],
    sys.stdout.flush()
    time.sleep(.3)
    print "\b\b\b",
    sys.stdout.flush()
    i = (i + 1)%4
output = process.communicate()

另一个脚本是

#!/usr/bin/env python

import os
import logging as log_status

class upgradestatus():
    def __init__(self):
        if (os.path.exists("/tmp/updatestatus.txt")):
                os.remove("/tmp/updatestatus.txt")

        logFormatter = log_status.Formatter("%(asctime)s [%(levelname)-5.5s]  %(message)s")
        logger = log_status.getLogger()
        logger.setLevel(log_status.DEBUG)

        fileHandler = log_status.FileHandler('/tmp/updatestatus.txt', "a")
        fileHandler.setLevel(log_status.DEBUG)
        fileHandler.setFormatter(logFormatter) …