小编asc*_*ler的帖子

何时进行条件编译是一个好主意,什么时候是一个非常糟糕的主意呢？

通过条件编译,我的意思是使用#ifdefs仅在某些条件下编译某些代码位.所述#definedš本身可以是在任一个共同的头文件或经由引入的-D编译器指令.

我试图理解一些汇编代码,并设法完成大部分汇编代码,除了几行.我能够理解大部分内部发生的事情,但我无法完全理解代码开头和结尾发生了什么(以及为什么会发生).有人可以对此有所了解吗？

int main() {
    int a, b;
    a = 12;
    b = 20;
    b = a + 123;
    return 0;
}

拆卸版本:

 8048394:8d 4c 24 04          lea    0x4(%esp),%ecx              ; ??
 8048398:83 e4 f0             and    $0xfffffff0,%esp            ; ??
 804839b:ff 71 fc             pushl  -0x4(%ecx)                  ; ??
 804839e:55                   push   %ebp                        ; Store the Base pointer
 804839f:89 e5                mov    %esp,%ebp                   ; Initialize the Base pointer with the stack pointer
 80483a1:51                   push   %ecx                        ; ??
 80483a2:83 ec 4c             sub    $0x4c,%esp                  ; ??
 80483a5:c7 45 f8 …

考虑这个程序:

#include <memory>
#include <iostream>

class X
  : public std::enable_shared_from_this<X>
{
public:
  struct Cleanup1 { void operator()(X*) const; };
  struct Cleanup2 { void operator()(X*) const; };
  std::shared_ptr<X> lock1();
  std::shared_ptr<X> lock2();
};

std::shared_ptr<X> X::lock1()
{
  std::cout << "Resource 1 locked" << std::endl;
  return std::shared_ptr<X>(this, Cleanup1());
}

std::shared_ptr<X> X::lock2()
{
  std::cout << "Resource 2 locked" << std::endl;
  return std::shared_ptr<X>(this, Cleanup2());
}

void X::Cleanup1::operator()(X*) const
{
  std::cout << "Resource 1 unlocked" << std::endl;
}

void X::Cleanup2::operator()(X*) const
{
  std::cout << "Resource 2 unlocked" …

我偶然发现了这段代码:

if source[0] != ?/
  source = compute_asset_path(source, options)
end

这是什么" ?/"？我从未见过以这种方式写字符串.

$ irb
2.0.0p247 :001 > ?/
=> "/" 

显然它只适用于单个字符:

2.0.0p247 :001 > ?a
 => "a" 
2.0.0p247 :002 > ?foo
SyntaxError: (irb):2: syntax error, unexpected '?'

什么?意思？

我想设计一个类模板,它采用分配器类型(在标准部分17.6.3.5中定义)作为模板参数.我看到如何使用默认设置来std::allocator_traits<A>填充任何缺少的成员A.除此之外,标准库或增强中是否有任何东西可以帮助正确使用分配器？

特别是:

1. 为了尊重typedef std::allocator_traits<A>::propagate_on_container_copy_assignment,我是否必须在具有类型成员的每个类的特殊成员函数中检查这些内容A？或者是否有一些我可以用作成员的包装类型来代替它来处理这些东西？

2. 如果我想通过在用户可见对象旁边存储额外数据来进行全面分配以减少分配数量,那么重新绑定分配器是否合适呢？

.

template<typename T, typename A>
class MyClass
{
private:
    //...
    struct storage {
        int m_special_data;
        T m_obj;
    };
    typedef typename std::allocator_traits<A>::template rebind_alloc<storage>
        storage_alloc;
    typedef typename std::allocator_traits<A>::template rebind_traits<storage>
        storage_traits;
    storage_alloc m_alloc;

    static T* alloc(T&& obj)
    {
        storage_traits::pointer sp = storage_traits::allocate(m_alloc, 1);
        sp->m_special_data = 69105;
        return ::new(&sp->m_obj) T(std::move(obj));
    }
    //...
};

我AlertDialog只有一些文字,一个NumberPicker,一个OK,一个取消.

package org.dyndns.schep.example;
import android.os.Bundler;
import android.view.View;
import android.widget.NumberPicker;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.app.DialogFragment;
import android.content.DialogInterface;

public class FooFragment extends DialogFragment {
    @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);
        mParent = (MainActivity) activity;
    }

    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
        builder.setPositiveButton(android.R.string.ok,
                new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int id) {
                mParent.setFoo(foo());
            }
        })
        .setNegativeButton(android.R.string.cancel, null);

        View view = getActivity().getLayoutInflater.inflate(
                R.layout.dialog_foo, null);
        mPicker = (NumberPicker) view.findViewById(R.id.numberPicker1);
        mPicker.setValue(mParent.getFoo()); …

从C++中的GCC 6开始,unique_ptr<T[]>::reset方法的声明/定义(不是仅接受的方法nullptr_t)如下所示:

template <typename _Up,
            typename = _Require<
              __or_<is_same<_Up, pointer>,
                    __and_<is_same<pointer, element_type*>,
                           is_pointer<_Up>,
                           is_convertible<
                             typename remove_pointer<_Up>::type(*)[],
                             element_type(*)[]
                           >
                    >
              >
           >>
  void
  reset(_Up __p) noexcept
  {
using std::swap;
swap(std::get<0>(_M_t), __p);
if (__p != nullptr)
  get_deleter()(__p);
  }

在某些时候改变了这一点以实现N4089.根据该文件:

此函数的行为与主模板的重置成员相同,除非它不参与重载解析

- U是相同的类型pointer,或者

- pointer是类型element_type*,U是指针类型V*,V(*)[]可以转换为element_type(*)[].

让我们考虑以下示例:

std::unique_ptr<const char []> ptr1;
std::unique_ptr<char []> ptr2(new char[5]);
ptr1 = std::move(ptr2);

由于版本6 GCC产生错误,抱怨它无法std::swap使用const char*& …

我有一个目录列表,我想要检索文件名并将它们放在一个字符串向量中,以便它们以"自然"的方式排序.例如{ "10.txt" "0.txt" "2.txt" "1.m" "Jan12" "July13.txt" "Nov25.txt" "Jane" "John" }应该{"0.txt" "1.m" "2.txt" "10.txt" "Jan12" "July13.txt" "Nov25.txt" "Jane" "John" }.最简单的方法是什么？

在阐述"自然",我们假设从号码的部分组成的字符串(N)和文本(T)这样...(N)(T)...,那么对于...(N1)(T1)...和 ...(N2)(T2)...会(N1<N2) (<) (T1<T2),其中 (<)暗示了正确的长期左边项优先.在这种情况下,如果数字在字符串中处于相同位置,则数字优先于文本字段,即1.z (<) 1_t.txt.

是否已经有一个库函数来对字母数字字符串或目录条目进行那种排序？

期望的文件顺序.文件名将存储在字符串向量中.

Abhinav@Abhinav-PC /cygdrive/c/AbhinavSamples/shell
$ ls -lv
total 8
-rw-r--r--+ 1 Abhinav None 2 Mar 17 00:51 1.txt
-rw-r--r--+ 1 Abhinav None 2 Mar 17 00:55 1_t.txt
-rw-r--r--+ 1 Abhinav None 2 …

考虑以下代码:

int x = 0;

template<int& I>
struct SR {};

template<int* I>
struct SP {};

SR<(x)> sr;
SP<&(x)> sp;

int main(void)
{
}

clang ++ 3.8.0抱怨:

main.cpp:10:5: error: non-type template argument does not refer to any declaration
SP<&(x)> sp;
    ^~~
main.cpp:6:15: note: template parameter is declared here
template<int* I>
              ^

g ++ 6.1.0抱怨:

main.cpp:10:8: error: template argument 1 is invalid
 SP<&(x)> sp;
        ^

当然,如果我删除括号,一切正常,如SP<&x> sp;.但是我在C++ 14标准中找不到任何会在这里产生影响的东西.此外,为什么参考案例没问题,但指针案例不好？编译器是否正确拒绝该程序？

有几个很好的理由可以选择

#include <cstdlib>

template<typename T, std::size_t N>
constexpr std::size_t ARRAY_COUNT_FUNC(T (&arr)[N]) { return N; }

而不是

#define ARRAY_COUNT_MACRO(arr) (sizeof(arr)/sizeof(*arr))

一个重要的区别是,当一个指针(不是一个数组)被传递给ARRAY_COUNT_MACRO它时,它会静默地返回一个无用的答案,但传递相同的参数ARRAY_COUNT_FUNC会导致编译错误指出错误.

但宏确实有一个优势:它的论点没有评估.

#include <utility>
struct S {
    int member_array[5];
};

// OK:
std::size_t count1 = ARRAY_COUNT_MACRO(std::declval<S&>().member_array);

// ERROR: std::declval is odr-used!
std::size_t count2 = ARRAY_COUNT_FUNC(std::declval<S&>().member_array);

还有另一种方法可以同时获益吗？例如,如果参数不是数组,则会导致编译错误,并且不会使用其参数.