Sashkinzz's questions

j=float(0.15+0.005*62)
print(j)#0.45999999999999996 
number = 3.1415926535

formatted_number = f"{j:.5f}" 
print(formatted_number) #выводит 46.00000
formatted_number = f"{number:.5f}" 
print(formatted_number) #выводит 3.14159

我需要在变量 j=0.45999999999999996 中保留 5 个小数位而不进行四舍五入，但它始终四舍五入。此外，它可以正确地处理一个变量，但不能处理另一个变量。如何解决问题？我肯定不仅需要打印数字，还需要写下它的值。

cat $* | while read line 在进入循环之前，您如何理解这是文件中的最后一行，并且在下次运行时将处理脚本的第二个参数？

string h;
h = 's' + "ss";// справа строка?
cout << endl << h;// выводит странный символ 
 
string h1('s'+"ss");// конструктор есть

问题：如果 's'= char，“ss”= const char[3]，最终结果是什么类型，添加后最有可能（我不确定）转换为 const char*

vector<int> m={1,2,3};
m.begin()++;
cout<<m[0];}

问题是，为什么迭代器的值没有变成第0个元素呢？

class a{
public:
int y;
void f(){cout<<6;}
};

class b: public a{
public: 
int y;
void f(){cout<<7;}
};

为什么可以让函数和变量与父类同名呢？也就是说，为什么继承人中不会出现名称冲突，因为父代的所有这些方法和字段都已经存在于其中？

const char k[3]={1,2,3};
char v[3] = k;
char d[] = "kk";  // const char[3]kk но еще это и константный литерал

我真的不明白为什么可以用常量文字初始化数组，它也是一个数组，但常规数组却不是。我知道在常规数组的情况下应该进行逐字符复制，但为什么它在第二种情况下有效？

int y=0;
double z=1.9;
y=z;

int* py;
double* pz;
//py=pz; error
//int& rp=z; error

问题：为什么可以将一种类型的变量赋给另一种类型的变量，但不能使用指针和引用？

string s="55", s1="5";

cout<<(s>s1);//true

cout<<("55">"5");//false

为什么在不创建变量的情况下比较工作不正确？

template <int>
int foo()
{
    int y=9;
    return y;
}

template <float>
float foo()
{
    float y=9;
    return y;
}

我希望能够通过一个函数名称处理不同的类型，所以我将其设为模板。但是会弹出一个错误。这是一个带有分数类的变体。

template<int>
int foo()
{
    int y=9;
    return y;
}

template <class Ratio>
Ratio foo()
{
    Ratio res(5,6);//здесь вместо конструктора, который есть, пишет про лист инициализации, и также ошибка
    return res;
}

为什么不能使用迭代器来显示它在容器中指向的对象的地址，如果我想找出地址的顺序？

int main()
{
    std::forward_list<int> list;
    list.push_front(5);
    list.push_front(4);
    forward_list<int>::iterator it=list.begin();
    cout<<it;
    cout<<*it;

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


class Node {
    friend class tree;
    int data;
    Node* l = NULL;
    Node* r = NULL;
    Node* parent = NULL;
    
public:
    Node(int d) :data(d) {};

    int node_get_data() {
        return data;
    }
    Node* node_get_left() {
        return l;
    }
    Node* node_get_right() {
        return r;
    }
    void node_set_left(Node* n) {
        l = n;
    }
    void node_set_right(Node* n) {
        r = n;
    }
    void node_set_data(int n) {
        data = n;
    }
    void node_set_parent(Node* n) {
        parent = n;
    }


};

class tree {
    Node* root = NULL;
public:
    tree(Node* n, int size) {//constructor
        root = n;
        --size;
        insert(n+1, root, size);

    };

    tree(Node n) {// only root there
        root = &n;
    };

    Node* add_elem(Node n) {
        insert(n, root);
        return root;
    }

    Node insert(Node n,Node* current){
        if (root == NULL)
            root = &n;

        if (n.node_get_data() > current->node_get_data())
            if (current->node_get_right() == NULL)
            {
                current->node_set_right(&n);
                current->node_get_right()->node_set_parent(current);
            }
            else insert(n, current->node_get_right());

           
        else if (current->node_get_data() > n.node_get_data())
            if (current->node_get_left() == NULL)
            {
                current->node_set_left(&n);
                current->node_get_left()->node_set_parent(current);
            }
            else insert(n, current->node_get_left());

        return n;
    }

    Node* insert(Node* n, Node* current,int size)// for arrays 
    {

        static int c = 0;
       /*while*/ if (c != size) {
           
            if ((current->node_get_data()) < (n->node_get_data()))
                if (current->node_get_right() == NULL)
                {
                    current->node_set_right(n);
                    current->node_get_right()->node_set_parent(current);
                    ++c;
                    insert(n + 1, root,size);
                }
                else
                    insert(n, current->node_get_right(),size);

            else if (current->node_get_data() > n->node_get_data())
                if (current->node_get_left() == NULL)
                {
                    current->node_set_left(n);
                    current->node_get_left()->node_set_parent(current);
                    ++c;
                    insert(n + 1, root,size);
                }
                else
                    insert(n, current->node_get_left(),size);
        }
        return n;
    }



    void print() {
        printo(root);
    }

    void printo(Node* current) {
        if (current != NULL)
        {
            printo(current->node_get_left());
            cout << current->node_get_data()<<"\t";
            printo(current->node_get_right());
        }
       

    }

};



int main()
{
    Node n(7);
    Node n1(8);
    Node n2(10);
    Node n3(6);
    Node n4(5);
    Node n5(11);
    Node arr[5] = { n,n1,n2,n3,n4 };
   
    tree tr(arr,sizeof(arr)/sizeof(Node));
    tr.add_elem(n5);
    tr.print();

}

为什么外部类不能创建内部类的对象？

class d {
public:
    int data = 90;
    static const int n = 9;

    class t {
        friend class d;
        int yy = 0;
    public:
        int y;
        t(int b) :y(b) {};
        const int v = d::n;//тк статик не через объект
    };
    t nn(3);//ошибка?

   map<int,string> h;
h[1]="q";
h[20]="d";
h[3]="s";
h[90]="l";
h[9]="f";

map<int,string>::iterator it;
for(it=h.begin();it!=h.end();++it)
    cout<<it->first<<"\t";
cout<<"\n"<<h.end()-- ->first;