小编Kor*_*elK的帖子

我的问题主要是关于术语以及如何解释标准。

[expr.rel]#4 :

比较指向对象的不等指针的结果是根据符合以下规则的偏序定义的：

(4.1) 如果两个指针指向同一个数组的不同元素，或者指向其子对象，则要求指向下标较高的元素的指针比较大。

(4.2) 如果两个指针递归地指向同一对象的不同非静态数据成员，或指向此类成员的子对象，则要求后面声明的成员的指针比较大，前提是这两个成员具有相同的访问控制（ [class.access])，两个成员都不是零大小的子对象，它们的类也不是联合。

(4.3) 否则，两个指针都不需要比较大于另一个。

我对如何解释（4.3）有点困惑。这是否意味着这

#include <iostream>
int main() {
    int x;
    int y;
    std::cout << (&x < &y);
    std::cout << (&x < &y);
}

是...

• 有效的 C++ 代码，输出为11或00。
• 无效代码，因为它具有未定义的行为

?

换句话说，我知道（4.3）确实适用于此，但我不确定其含义。当标准说“它可以是 A 或 B”时，这与说“它是未定义的”相同吗？

如何将具有派生模板实例化的对象传递给接受具有基本模板实例化的这些对象的方法？

似乎有可能，因为 std::shared_ptr 或 std::pair 似乎能够做到。

例如

#pragma once

#include <iostream>
#include <memory>

struct Base {
    virtual void print() = 0;
};

struct Derived : public Base {
    void print() {
        std::cout << "Got it!" << std::endl;
    }
};

void printBase(const std::shared_ptr<Base> &ptr){
    ptr->print();
}

void printBase(const std::pair<Base&, Base&> &pr){
    pr.first.print();
}

template <typename T>
struct Wrap {
    T& t;
};

void printBase(const Wrap<Base> &wrap) {
    wrap.t.print();
}

int main() {
    Derived d;
    std::shared_ptr<Derived> ptr = std::make_shared<Derived>(d);
    printBase(ptr); // works …

这是我的代码:

$.ajax({   
    type: "POST",
    url: "localhost/api.php",
    data: {id:user_id},
    cache: false,
    success: function(data) {

        var obj = $.parseJSON(data); 
        if (obj.msg == "1")
        {
            $.each(obj.userList, function(i,value) {
                var jArray = <?php echo json_encode($groupData ); ?>;
                list = [];
                for (var i = 0; i < jArray.length; i++) {
                    list.push('<option id=' + jArray[i].Group_Id + ' value=' + jArray[i].Group_Name + '>' + jArray[i].Group_Name + '</option>');
                }
                var html ="<tr>"+
                        "<td>"+value['id']+"</td>"+
                        "<td>"+value['groupID']+"</td>"+ 
                        "<td><select name='Group[]''>"+list+ "</select></td>";
                $('table#List tbody').append(html);

            });
        }
    },
    alert('Error');
});

我正在基于ajax响应动态构建html.在代码段>中

 var jArray …

假设对于给定的整数 N，我需要运行 N 次的循环平方根。

在 C++ 中，我可以通过这两种方式来做到这一点——

1)

long long sqrtN = std::sqrt(N);
for (long long i=1; i < sqrtN; i++) {
    // some piece of code
}

for (long long i=1; i * i < N; i++) {
    // some same piece of code
}

我发现 std::sqrt() 具有 O(logn) 复杂度。另外，我相信数字的乘法只是一个常数时间运算。

所以，感觉第2个版本更快。但是，对于非常大的 n 值，第二个版本中的恒定时间可能很重要。

因此，我不确定哪种方式更有效？