小编ont*_*cks的帖子

这是参考本主题中的讨论, 如何将char指针作为C++函数的out参数

在下面的代码中,我在哪里释放pTemp的内存？这不是必需的吗？如果不是字符数组而不是整数数组,事情会不会发生变化？

void SetName( char **pszStr )
{
    char* pTemp = new char[10];
    strcpy(pTemp,"Mark");
    *pszStr = pTemp;
}

int main(int argc, char* argv[])
{
    char* pszName = NULL;
    SetName( &pszName );
    cout<<"Name - "<< pszName << endl;
    delete [] pszName;
    cin.get();
    return 0;
}

有3个整数变量,其值可以是0或1.如果全部为0或全部为1,则打印特定语句.对于所有其他值组合,打印另一个语句.

我尝试了下面的工作.是否有更好的方法来编写if语句？

#include <iostream>
using namespace std;

int main()
{
    int a, b, c;
    cin >> a >> b >> c;

    if(!(a != 0 && b != 0 && c != 0) && !(a == 0 && b == 0 && c == 0))
    {
        cout << "a, b or c have mixed values of 1 and 0" << endl;
    }
    else
    {
        cout << "All of a, b and c are either 1 or 0" << endl;
    }

    system("pause"); …

请参阅此处的文件http://www.open-std.org/Jtc1/sc22/wg21/docs/papers/2011/n3242.pdf

"具有静态存储持续时间(3.7.1)或线程存储持续时间(3.7.2)的变量应在任何其他初始化发生之前进行零初始化(8.5)"

如果我拥有所有内容,即单个文件中的类声明和main()(必须),我应该能够省略初始化.但是,如果我省略,我在构建期间会出现"未定义的引用"错误.

#include <iostream>
using namespace std;

class foo
{
    public:
        static int array[2];
};

int foo::array[2] = {0}; //I should be able to omit this line

int main()
{
    cout << "foo::array[0] = " << foo::array[0] << endl;
    return 0;
}

PS:没有C++ 11

我有一个类有成员的类 std:vector

  private:
     std::vector<int> myVector;

我创建了Get方法来访问 myVector

1. const std::vector<int>   GetMyVector() const;
2. const void   GetMyVector(std::vector<int>& vec) const;

实现分别如下:

1. const std::vector<int> MyClass::GetMyVector() const
   {
       return  myVector;
   }

2. const void MyClass::GetMyVector(std::vector<int>& vec) const
   {
       vec =  myVector;
   }

两种Get方法中哪一种更好,为什么？

以下是一个返回整数的简单函数定义

int myFunc()
{
    int localVar = 99;
    return localVar;
}

它主要称为

int main()
{
    int y = myFunc();
    cout << y << endl;
    return 0;
}

这按预期工作.我想知道为什么？ localVar是一个局部变量,其值在堆栈中分配.一旦功能结束,它就会超出范围.那么,localVar在调用范围内会超出范围int y = myFunc();如何/为什么它仍然能够返回正确的值？

我有一个带有成员的A类,它是另一个B类的对象指针的向量

class A
{
    std::vector<B*> m_member_A

m_member_A通过使用new运算符创建B的对象来填充

B* b1 = new B;
m_member_A.push_back(b1);

在A的析构函数中,以下是否正确释放所有内容？

A::~A()
{
    for(int i = 0; i < m_member_A.size(); ++i)
    {
        delete m_member_A[i];
    }

    m_member_A.clear();
}

有一些函数将枚举作为参数

void myfunc(myEnum input);

据我了解，如果必须为此函数提供一个整数，建议将其显式转换为枚举，原因是所有整数可能都不是有效的枚举值。

根据MSDN

“ static_cast运算符可以将整数值显式转换为枚举类型。如果整数类型的值不在枚举值的范围内，则所得的枚举值不确定。”

并按照C ++标准5.2.9静态转换-> 10

“整数或枚举类型的值可以显式转换为枚举类型。如果原始值在枚举值（7.2）的范围内，则该值不变。否则，结果值未指定（并且可能不在该范围）。”

那么static_cast在这种情况下使用的意义是什么？是否有一些选项会引发超出枚举范围的值的异常（除了为此编写显式代码）？

我有以下内容

stages:\n    - stage1\n    - stage2\nvariables:\n\xc2\xa0\xc2\xa0\xc2\xa0\xc2\xa0    MY_ENV_VAR:\xc2\xa0env_$CI_JOB_ID\nstage1_build:\n    stage: stage1\n    script:\n        - echo $MY_ENV_VAR\nstage2_build:\n    stage: stage2\n    script:\n        - echo $MY_ENV_VAR\n

$MY_ENV_VAR我在两个阶段得到不同的值（这意味着$CI_JOB_ID每个阶段都有变化）。

我想要的是设置$MY_ENV_VAR一次 的一个值$CI_JOB_ID并将其设为常量，以便$MY_ENV_VAR在所有阶段使用相同的值。

所以我有两个变量

$x = q(foo);
$y = q(bar);

我的目标是在第三个变量中使用它们,它们之间有下划线即foo_bar.有很多方法可以做到这一点,但我想使用qq

所以

$z = qq($x_$y);

这会产生以下错误

Global symbol "$x_" requires explicit package name at test.pl line 45.
Execution of C:\test.pl aborted due to compilation errors.

所以我不得不使用大括号和变量x来使它工作

$z = qq(${x}_$y);

为什么下划线不起作用qq？在这种情况下,为什么我需要大括号？

我的机器中有以下预先存在的文件夹

D:\scripts\myfolder

我希望我的脚本创建一个名为 的文件夹并在其中logs创建一个文件。log.txt所以路径看起来像

D:\scripts\myfolder\logs\somelog.txt

所以我用了

p = pathlib.Path("D:\scripts\myfolder\logs\somelog.txt")
p.mkdir(parents=True, exisit_ok=True)

现在

print(p.parents[0])==>D:\scripts\myfolder\logs

print(p.parents[1])==>D:\scripts\myfolder

print(p.parents[2])==>D:\scripts

因此，根据Path.mkdir文档 p.mkdir(parents=True, exisit_ok=True)应该创建文件夹logs，myfolder或者scripts等等（如果它们不存在）。

some.txt但它会按inside文件夹的名称创建一个文件夹logs，尽管它不是parents. 为什么会这样？

我知道解决方法是使用pathlib.Path("D:\scripts\myfolder\logs")

我见过很多次人们在派生类构造函数初始值设定项列表中添加基类的默认构造函数，如下所示

DerivedClass::DerivedClass(int x) : BaseClass(), member_derived(x)
{
    //Do something;
}

派生类构造函数默认调用基类的默认构造函数。BaseClass()上面的初始化列表中的是多余的吗？

假设有一个抽象类A和两个类B及C衍生自A和B分别

class A
{
    virtual void print() = 0;
};

class B : public A
{
    void print(); 
};

//print() must be implemented
void B::print()
{
    std::cout << "Hello" << std::endl;
}

class C : public B
{
    //print() does not require to be implemented
};

我理解,C从其直接父级的角度来看B,print()不是纯粹的虚方法,但是从C祖父母的角度来看A,print()是一种纯虚方法.那么,它不应该也需要实施C吗？

如何将原始字符串文字R与固定宽度整数类型的格式宏一起使用？

例如

std::int64_t num = INT64_MAX;
std::printf(R"("name":"%s", "number":"%")" PRId64, "david", num); // wrong syntax

输出应该是

"name":"david", "number":"9223372036854775807"

R不允许使用转义序列代替