小编Rem*_*eau的帖子

对于下面的函数，与使用相比，A我使用时得到了不同的结果。前者给出的结果为，后者给出的结果为。est += XXXest = est + XXX1.33227e-158.88178e-16

另一方面，对于B下面的函数，无论我是否使用est += XXX或 ，我都会得到相同的结果est = est + XXX。

有人能解释为什么x+=y相当于x=x+yin 函数B而不是 in 吗A？

功能A

double A(int nTerm){
    const double PI = 3.141592653589793238463;    
    double est = 0;
    double counter = 0;

    do {
        est += ( 16 * pow(-1,counter) )/ (2*counter+1) * pow((double)1/5, 2*counter+1) 
             - ( 4 * pow(-1,counter) )/ (2*counter+1) * pow((double)1/239, 2*counter+1);
        counter++; …

我正在使用 C++ 为 Windows/Linux 开发一个软件。

我想在运行时创建一个文件（txt、json、许可证，你能想到的），并将其保存在某个地方。在 C++ 中是否可以获取该文件在磁盘上的确切位置，以便如果我重新启动应用程序并读取该地址（或其他地址），我将能够访问其数据？

这样做的目的是，如果有人将软件复制到另一个操作系统，或创建操作系统的映像并尝试运行它，则该地址将不再有效并且会失败。这是尝试添加另一层（在许可证管理之上）以防止软件复制。

我是学习 C++ 的初学者。就在今天，我尝试学习布尔运算符和if-else语句。

这是代码：

int main(){
    //if-else statement
    int a, b;
    bool result = (a < b);
    
    std::cout << "input number 1 : ";
    std::cin >> a;
    std::cout << "input number 2 : ";
    std::cin >> b;
    std::cout << std::boolalpha << result <<std::endl;
    if(result == true){
        std::cout << a << " is less than " << b << std::endl;
    }
    if(!(result == true)){
        std::cout << a << " is NOT less than " << b << std::endl;
    } …

class test {
public:
    test(int i) : t(10) {
        cout << "cst" << i << endl;
    }

    static test ins;
    const test t;// 1
};

在第 1 行，编译器失败并出现错误：

不允许不完整的类型

这是为什么？

我想知道如何简化如下所示的声明。

我到处都有类似的代码，想清理它。

if(isActive)
{
    if(columnId == 4)
        g.drawText(active[row].value, 2, 0, width, height, Justification::centredLeft, true);
}
else
{
    if(columnId == 4)
        g.drawText(inactive[row].value, 2, 0, width, height, Justification::centredLeft, true);
}

isActive正如您可以想象的那样，是一个bool值。

我有一个使用 CRTP 和 C++20 的代码：

template<class Derived>
class Base {
public:

    void m() {
        static_cast<Derived*>(this)->feature();      
    }
   
    virtual constexpr void feature() = 0;
}

class BaseImpl: public Base<BaseImpl> {
     virtual constexpr void feature() final override  { // ... };
}

有没有办法删除vptr，这样对象就不会占用 8 个字节（对于 x64），而只占用 1 个字节？（因为它从不使用运行时多态性）？

在实际代码中，层次结构要复杂得多，有 2 个vptr（因此需要 16 个字节）。是否有类似 GCC 或 MSVC 的扩展？

是的，当然，解决方案之一就是删除该virtual方法。但由于它具有复杂的层次结构，它带来了极其丑陋的错误和不可维护的代码，因为程序员应该通过读取不可读的模板实例化错误来猜测必须实现哪些方法。

整个目标是实现类似 Java 的层次结构（具有接口、覆盖检查等），但具有零成本抽象。

我做了一些实验（探索代码反汇编），编译器完全优化了所有虚拟调用，提供了零成本抽象。除了它将对象扩展为具有vptr我的代码中从未使用过的 a 。

我发现了类似的东西__declspec(novtable)，但vptr仍然占用空间。是的，物体的尺寸尽可能小是极其重要的。

对于codeforces问题：

https://codeforces.com/problemset/problem/339/A

以下程序在第七次测试中显示运行时错误：

#include<iostream>
using namespace std;

int main()
{
    char s[100];
    cin>>s;
    int i;
    string a,b,c;
    int j=0,k=0,l=0;
    for(i=0;s[i]!='\0';i++)
    {
        if(s[i]=='1')
        {
            a[j]='1';
            a[j+1]='+';
            j+=2;
        }

        if(s[i]=='2')
        {
            b[k]='2';
            b[k+1]='+';
            k+=2;
        }

        if(s[i]=='3')
        {
            c[l]='3';
            c[l+1]='+';
            l+=2;
        }
    }
    char str[100];
    int x,y,z;
    for(x=0;x<=j-1;x++)
    {
        str[x]=a[x];
    }

    for(y=0;y<=k-1;y++,x++)
    {
        str[x]=b[y];
    }

    for(z=0;z<=l-1;z++,x++)
    {
        str[x]=c[z];
    }

    int q;
    for(q=0;q<=x-2;q++)
    {
        cout<<str[q];
    }

    return 0;
}

测试用例是：

2+3+3+1+2+2+2+1+1+2+1+3+2+2+3+3+2+2+3+3+3+1+1+1+3+ 3+3+2+1+3+2+3+2+1+1+3+3+3+1+2+2+1+2+2+1+2+1+3+1+1

string a,b,c;当我更改为时答案被接受char a[100],b[100],c[100];

我无法理解为什么string这里的数据类型导致运行时错误。

我猜这可能是由于测试用例的长度造成的，但我不确定为什么。

我有这4个功能：

function ALmyfunctA(const Filename: AnsiString): Boolean;
function ALmyfunctW(const Filename: String): Boolean;
function ALmyfunct(const Filename: AnsiString): Boolean; overload;
function ALmyfunct(const Filename: String): Boolean; overload;

他们是做这样的事情的简单方法吗？

function ALmyfunct(const Filename: AnsiString): Boolean; = function  ALmyfunctA(const Filename: AnsiString): Boolean;

和

function ALmyfunct(const Filename: String): Boolean; = function  ALmyfunctA(const Filename: String): Boolean;

我可以使用var：

var ALmyfunct: function(const Filename: String): Boolean;

但它不适用于overload:(

那么，有办法做到这一点吗？

我想定义两个类A，并I以它们的对象尊重这种关系的方式：

i1 -----------a1
  |------a2
  |----a3

• 该类的一个实例I指向该类的零个、一个或多个实例A。

• 类的一个实例A仅指向该类的一个实例I。

• 类的实例I可以没有任何类的实例A，但类的实例必须“附加”A类的实例。I

为了满足这些条件，我将这两个类声明如下：

class I;
class A
{
    private:
        std::string as;
        std::shared_ptr<I> iA;        
    public:
        A(std::string aTxt);
        A();
        ~A();
};

class I
{
   private:
       std::string ip;
       std::vector<std::unique_ptr<A>> as;
       friend class A;
   public:
       I(std::string i);
       ~I();
};

在源文件中，我以这种方式定义了这两个类：

A::A(std::string aText)
{
    as = aText;
}

A::A()
{
    as = "";
}

A::~A()
{
}

I::I(std::string i)
{ …

我有一个数组，MyStruct* my[100];我在循环中设置数据，如下所示：

if id > X && id < Y { my[id-X] = p;

现在我想访问my[0]as name0、my[1]as different1、my[2]asanotherThing等。

我该怎么做呢？我尝试了union+X宏，但这在 gcc 中不起作用（它在 clang 中起作用）。

我想我必须编写一个脚本，这样我就不会手写所有的#defines，但我认为#define anotherThing my[2]这是给出数组项名称的唯一方法，对吗？我想简单地写different1->myStructMember，而不是my[123]->myStructMember每次都写，这样不可读。