小编con*_*ong的帖子

C++ primer,5th,14.8.2,使用带有算法的库函数对象:

vector<string *> nameTable;  // vector of pointers
// error: the pointers in nameTable are unrelated, so < is undefined
sort(nameTable.begin(), nameTable.end(),
     [](string *a, string *b) { return a < b; });
// ok: library guarantees that less on pointer types is well defined
sort(nameTable.begin(), nameTable.end(), less<string*>());

然后我检查了std :: less实现:

template<typename _Tp>
struct less : public binary_function<_Tp, _Tp, bool>
{
  bool
  operator()(const _Tp& __x, const _Tp& __y) const
  { return __x < __y; }
};

我发现std :: less也使用operator <来完成工作,所以为什么<未定义且库保证指针类型的定义较少,为什么std:少推荐,为什么std …

我想签署我的apk,所以我执行了以下命令:

java -jar signapk.jar platform.x509.pem platform.pk8 app-debug.apk~/Desktop/test.apk

但我收到以下错误:

线程"main"中的异常java.lang.UnsatisfiedLinkError:java.lang.ClassLoader.loadLibrary(ClassLoader.java:1867)的java.library.path中没有conscrypt_openjdk_jni,java.lang.Runtime.loadLibrary0(Runtime.java:870) atg.conscrypt.OpenCrypto的一个org.conscrypt.NativeCrypto的org.conscrypt.NativeCryptoJni.init(NativeCryptoJni.java:25)上的java.lang.System.loadLibrary(System.java:1122).(NativeCrypto.java:54)org.conscrypt.OpenSSLBIOInputStream在org.conscrypt.OpenSSLX509Certificate.fromX509PemInputStream(OpenSSLX509Certificate.java:119)在org.conscrypt.OpenSSLX509CertificateFactory $ 1.fromX509PemInputStream(OpenSSLX509CertificateFactory.java:220)在org.conscrypt.OpenSSLX509CertificateFactory $ 1.fromX509PemInputStream(OpenSSLX509CertificateFactory.(OpenSSLBIOInputStream.java:34) .java:216)at org.conscrypt.OpenSSLX509CertificateFactory $ Parser.generateItem(OpenSSLX509CertificateFactory.java:94)at org.conscrypt.OpenSSLX509CertificateFactory.engineGenerateCertificate(OpenSSLX509CertificateFactory.java:272)at java .security.cert.CertificateFactory.generateCertificate(CertificateFactory.java:339)at com.android.signapk.SignApk.readPublicKey(SignApk.java:182)at com.android.signapk.SignApk.main(SignApk.java:1087)

如何解决这个错误？

(openjdk版本"1.8.0_141"OpenJDK运行时环境(版本1.8.0_141-8u141-b15-3~14.04-b15)OpenJDK 64位服务器VM(版本25.141-b15,混合模式))

我阅读了APUE 3rd , 11.6.1 Mutexes ，本章中有一个关于锁定和解锁互斥锁的示例：

struct foo {
    int             f_count;
    pthread_mutex_t f_lock;
    int             f_id;
    /* ... more stuff here ... */
};

struct foo *
foo_alloc(int id) /* allocate the object */
{
    struct foo *fp;

    if ((fp = malloc(sizeof(struct foo))) != NULL) {
        fp->f_count = 1;
        fp->f_id = id;
        if (pthread_mutex_init(&fp->f_lock, NULL) != 0) {
            free(fp);
            return(NULL);
        }
        /* ... continue initialization ... */
    }
    return(fp);
}

void
foo_hold(struct foo *fp) /* add a reference to the …

当我们编写一个可能会改变errno的信号处理程序时，我们是否应该在信号处理程序的开头保存errno并在它的末尾恢复errno？就像下面一样：

void signal_handler(int signo){
    int temp_errno = errno;
    *** //code here may change the errno
    errno = temp_errno;
}

一般来说，如果我们想在Linux内核中使用当前的宏，我们应该：

#include <asm/current.h>

但有一个 asm 通用版本：

#include <asm-generic/current.h>

asm版本通过per-cpu变量实现当前宏，而asm-generic版本通过thread_info实现当前宏，这两者完全不同。Linux内核头文件组织说我们应该使用asm版本，其中包括asm/current.h，但是很多博客或书籍都说x86使用asm通用版本来实现当前的宏，包括Linux内核开发，3rd，3进程管理，存储进程描述符。那么，x86 Linux 内核真正使用哪个版本，asm还是asm-generic？如何确定 Linux 内核真正使用的是哪个版本？

据我所知，堆栈内存在虚拟内存地址中是连续的，但是堆栈内存在物理上也是连续的？这与堆栈大小限制有关吗？

编辑：

我曾经认为堆栈内存不必在物理上是连续的，但是为什么我们认为堆栈内存总是比堆内存快？如果它在物理上不是连续的，那么堆栈如何利用缓存的更多优势？还有另一件事总是让我感到困惑，cpu在数据段中执行指令，该指令不在虚拟内存中的堆栈段附近，我认为操作系统不会使堆栈段和数据段在物理上彼此靠近，因此这可能会损害缓存效果，您认为呢？

再次编辑： 也许我应该举一个例子来更好地表达自己，如果我们想对大量数字进行排序，使用数组存储数字要比使用列表更好，因为每个列表节点都可以由构造malloc，因此没有充分利用缓存，这就是为什么我说堆栈内存比堆内存快。

众所周知，/system/bin/linker负责动态链接机制，但libdl具有实际在动态链接器 ( ) 中定义的函数存根dlfcn.c，并在运行时被劫持，如下所示：

#include <dlfcn.h>
/* These are stubs for functions that are actually defined
 * in the dynamic linker (dlfcn.c), and hijacked at runtime.
 */
void *dlopen(const char *filename, int flag) { return 0; }
const char *dlerror(void) { return 0; }
void *dlsym(void *handle, const char *symbol) { return 0; }
int dladdr(const void *addr, Dl_info *info) { return 0; }
int dlclose(void *handle) { return 0; }

void android_update_LD_LIBRARY_PATH(const char* …

int method1() {
    return 0;
}

decltype(method1) method2() {
    return method1;
}

我编译我的代码,得到一个错误:'method2'声明为函数返回一个函数,然后我将返回类型更改为函数指针,它工作,我只是想为什么它是这样.

decltype(method1) *method2() {
    return method1;
}

在c ++ primer 5th,9.2.5中.分配和交换,我读到了这个:

元素不移动的事实意味着,除了字符串之外,迭代器,引用和指向容器的指针都不会失效.它们指的是与交换之前相同的元素.

那么,为什么字符串是一个例外？我一直认为字符串是一个向量,是不是真的？

我想知道为什么需要内存屏障，我已经阅读了一些关于这个主题的文章。
有人说这是因为cpu乱序执行，而另一些人说这是因为缓存一致性问题，存储缓冲区和无效队列导致。
那么，需要内存屏障的真正原因是什么？cpu乱序执行或者缓存一致性问题？或两者？cpu乱序执行和缓存一致性有关系吗？x86和arm有什么区别？

当你引用cppreference时,你会发现:

返回容器的最后一个元素后面的元素的迭代器.该元素充当占位符; 尝试访问它会导致未定义的行为.

然后我运行以下代码:

std::set<int> s {1, 2, 3};
cout << *s.end() << endl;

输出是:3,为什么？

有一个模板类A:

template<typename T>
class A {
public:
    T t;
    A(T t) {
        this->t = t;
        cout << "A constructor" << endl;
    }
    ~A() {
        cout << "A destructor" << endl;
    }
};

t是A类的成员,如果t是指向动态分配的内存的指针,那么默认的析构函数不能释放它,例如:

A<SomeType*> a(new SomeType());

因为我们不知道t是否是指针,所以我们不能像这样做解构函数:

~A() {
    delete t;
    cout << "A destructor" << endl;
}

我的问题是如何确保没有内存泄漏,无论是否是指针