小编kes*_*Him的帖子

我有一个c++ vector与std::pair<unsigned long, unsigned long>对象。我正在尝试使用std::next_permutation(). 但是，我希望排列具有给定的大小，您知道，类似于permutationspython 中指定预期返回排列大小的函数。

基本上，c++相当于

import itertools

list = [1,2,3,4,5,6,7]
for permutation in itertools.permutations(list, 3):
    print(permutation)

Python 演示

(1, 2, 3)                                                                                                                                                                            
(1, 2, 4)                                                                                                                                                                            
(1, 2, 5)                                                                                                                                                                            
(1, 2, 6)                                                                                                                                                                            
(1, 2, 7)                                                                                                                                                                            
(1, 3, 2)
(1, 3, 4)
..
(7, 5, 4)                                                                                                                                                                            
(7, 5, 6)                                                                                                                                                                            
(7, 6, 1)                                                                                                                                                                            
(7, 6, 2)                                                                                                                                                                            
(7, 6, 3)                                                                                                                                                                            
(7, 6, 4)                                                                                                                                                                            
(7, 6, 5) 

在docker 镜像SDKMAN!中安装时出现错误。Ubuntu 16.04

FROM ubuntu:16.04
RUN apt-get update
RUN rm /bin/sh && ln -s /bin/bash /bin/sh
RUN apt-get -qq -y install curl
RUN curl -s https://get.sdkman.io | bash
RUN chmod a+x "$HOME/.sdkman/bin/sdkman-init.sh"
RUN source "$HOME/.sdkman/bin/sdkman-init.sh"

首先，这个问题是不是问题的副本在这里。我目前正在学习 docker，并且需要创建一个在容器开始时使用以下命令dockerfile安装tomcat和运行它的entrypoint命令：

以下是我的内容dockerfile：

FROM ubuntu:latest

LABEL MAINTAINER="kesarling"

RUN apt update
RUN apt upgrade -y
RUN apt install apt-utils -y
RUN apt install maven gradle -y
RUN apt install wget tar zip unzip openjdk-14-jdk -y

RUN mkdir /usr/local/apache-tomcat-v8.5.55
RUN wget http://www-us.apache.org/dist/tomcat/tomcat-8/v8.5.55/bin/apache-tomcat-8.5.55.tar.gz -O /tmp/apache-tomcat-v8.5.55.tar.gz
RUN cd /tmp && tar xvfz apache-tomcat-v8.5.55.tar.gz
RUN cp -Rv /tmp/apache-tomcat-8.5.55/* /usr/local/apache-tomcat-v8.5.55/

RUN mkdir /usr/local/spring-v5.2.6
RUN wget https://repo.spring.io/release/org/springframework/spring/5.2.6.RELEASE/spring-5.2.6.RELEASE-dist.zip -O /tmp/spring-v5.2.6.zip
RUN cd /tmp && unzip spring-v5.2.6.zip
RUN cp …

我可以使用std::begin()and创建开始和结束迭代器std::end()。
例如：

int arr[4][4] = <something here>;
auto begin_it = std::begin(arr);
auto end_it = std::end(arr);

但是，为什么我们没有std::front()和std::back()。是否有任何特定原因可以省略它们？

我可以使用任何类似的功能（当然除了开始和结束）？

我对 cpp 比较陌生，正在学习智能点。我想知道以下几点：

为什么要构造std::unique_ptr一个lvalue允许的？

只允许构造std::unique_ptr带有右值的 an 来避免邪恶的事情不是更安全吗？

std::unique_ptr<int> createInt() {
    int* a = new int(99);
    std::unique_ptr<int> foo(a);
    delete a;
    return foo;
}

我意识到你必须疯了才能写出这样的东西，但我很高兴让编译器为此对你大喊大叫。所以我想知道，为什么 unique_ptr 的左值初始化是一件事？

编辑：用户@aler egal 更优雅地表达了我的想法：

“原则上，你可以有一个构造函数unique_ptr<int>(int*&& ptr)即假设PTR的所有权，然后将其设置为null。这将阻止释放后使用，在这个具体的例子（因为你被迫std::move(a)因为调用删除一个空指针有没有效果）但这将是一个非常奇怪的反模式。”

正如这里 所说std::string的不是模板函数，而是标准选择使用函数重载来为不同类型提供此函数。我的问题是，在这种情况下，当模板/专业化似乎对我更有意义时，为什么要使用重载？考虑一下，如果标准定义了这样的东西：

template <typename T>
std::string std::to_string(const T& v);

然后我们可以在我们的程序中自由地为任何类型添加特化以符合这个签名，因此 C++ 将有一种统一的方式将类型转换为人类可读的字符串。为什么不这样做？当前设计背后的想法是什么？

编辑1：

我对当前设计的主要批评std是不允许向 to 添加重载，因此我们不能编写任何类似的东西，std:to_string(object-that-is-of-user-defined-types)并且必须退回到to_string()在自己的命名空间中定义 a并记住在哪里使用他们的版本或std版本取决于他们正在处理的类型......这对我来说听起来很头疼。

我真正喜欢 Python（或其他一些语言）的一件事是，您可以通过实现一些魔术方法使自己的类型像本机类型一样工作。我认为这个问题的根本是为什么 C++ 决定禁止人们std::to_string()为他们自己的类型实现，从而禁止我们在任何地方都遵循相同的接口。

对于诸如hashor 之类的常见事物to_string()，在语言/stdlib级别上拥有单个界面，然后期望用户遵守该界面，而不是拥有多个界面，不是更好吗？

我在 SPOJ 上做了一个练习来练习高级算法。

问题陈述如下：

Harish 去超市为他的 'n' 个朋友买了正好 'k' 公斤的苹果。超市真的很奇怪。物品的定价是非常不同的。他去了苹果区询问价格。推销员给了他一张卡片，他在卡片上发现苹果的价格不是每公斤。苹果被装在盖子里，每个包含“x”公斤苹果，x > 0，“x”是一个整数。“x”公斤包裹的价值为“y”卢比。因此，标语牌包含一个表，其中条目“y”表示“x”公斤包的价格。如果 'y' 是 -1，则表示相应的数据包不可用。现在由于苹果只能以包形式提供，他决定最多为他的“n”个朋友购买“n”包，即他不会购买超过 n 包的苹果。Harish 非常喜欢他的朋友，所以他不想让他的朋友失望。

这是我用来解决问题的代码：

#include <algorithm>
#include <iostream>
#include <vector>

using std::cout;
using std::cin;
using std::vector;
using std::endl;

int MinValueOf(int a, int b)
{
    return (a < b) ? a : b;
}
int BuyingApple(vector<int> PriceaTag, int Friends, int KilogramsToBuy)
{
    vector<vector<int>> Table(Friends + 1, vector<int>(KilogramsToBuy + 1, 0));
    for(int i = 1; i <= Friends; i++)
    {
        for(int j = 0; j …

我目前正在学习智能指针并尝试执行以下操作：

#include <memory>
#include <string>

int main() {
    std::unique_ptr<std::string[]> str_array(new std::string[5]);
    for (int i = 0; i < 5; i++) {
        std::getline(std::cin, str_array.get()[i]);
    }
    return 0;
}

此代码只是将 5 个std::string对象扫描到一个数组中。但是，调试器显示没有为 5 个对象保留内存：

我究竟做错了什么？

我对码头工人的概念完全陌生。我正在创建以下 Dockerfile 作为练习。

FROM ubuntu:latest

MAINTAINER kesarling

RUN apt update && apt upgrade -y
RUN apt install nginx curl zip unzip -y
RUN apt install openjdk-14-jdk python3 python3-doc clang golang-go gcc g++ -y
RUN curl -s "https://get.sdkman.io" | bash
RUN bash /root/.sdkman/bin/sdkman-init.sh
RUN sdk version
RUN yes | bash -c 'sdk install kotlin'

CMD [ "echo","The development environment has now been fully setup with C, C++, JAVA, Python3, Go and Kotlin" ]

我正在使用SDKMAN！安装Kotlin. 最初的问题是RUN bash …

我有一个运行的 docker 映像tomcat。每当我部署一个分离的容器并使用 登录到该容器时docker exec，我通常会默认以 root 身份登录。但是，每当我尝试诸如 之类的命令时mount/umount，容器 shell 都会返回一个错误：must be superuser

这是什么错误以及如何修复它？

我刚刚创建了我的第一个 .NET 6 控制台应用程序，而不是默认的，

using System;
using System.Collections.Generic;
using System.Linq;

namespace MyApp
{
    public class Program
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

我有：

// See https://aka.ms/new-console-template for more information
Console.WriteLine("Hello, World!");

即使没有上课，程序也会运行！我查看了评论中提供的链接，但我不知道这是新功能还是旧功能。如果这是一个新功能，是否意味着 C# 今后将允许 C 风格编程？

（和cpp失去联系太久了，想复习一下明天的面试）。
正在修订深层复制与浅层复制。写了代码：

#include <iostream>

class MyClass {
public:
    unsigned int* uivar = nullptr;

    MyClass() : uivar(new unsigned int) {
        *(this->uivar) = 3;
    }

    ~MyClass() { delete uivar; }

    MyClass(const MyClass& mCopy) {
        *(uivar) = *(mCopy.uivar);
    }
};

void function(MyClass m) {
    *(m.uivar) = 4;
}

int main() {
    MyClass myClass;
    MyClass myClassCopy = myClass;
    std::cout << *(myClass.uivar) << "\n";
    std::cout << *(myClassCopy.uivar) << "\n";
    function(myClass);
    std::cout << *(myClass.uivar) << "\n";
    std::cout << "hhhh" << "\n";
    *(myClassCopy.uivar) = 5;
    std::cout << …