标签: std

我正在用 C++ 制作一个文本冒险，作为学习该语言的尝试。玩家使用“看”或“向北行进”等命令进行交互。到目前为止，我已经得到了将文本转换为小写然后将其拆分为向量的代码。这对于单字命令来说效果很好，但是当我去实现更长的命令时，我发现长度总是 = 1 并且访问它会返回错误。这是我的代码：

//Input function.
void Input() {
    const char delim = ' ';

    //Processing
    std::cin >> input;
    std::transform(input.begin(), input.end(), input.begin(),
        [](unsigned char c) { return std::tolower(c); });
    std::vector<std::string> out;
    split(input, ' ', out);

    //Commands
    if (out[0] == "exit")
        exit(0);
    else if (out[0] == "help")
        Help();
    else if (out[0] == "look")
        Look();
    else if (out[0] == "travel" || out[0] == "go") {
        //This code will never run.
        if (int(out.size()) == 2) {
            Travel(out[1]); …

我想使用带有以下自定义键的标准地图：

struct ParserKey{
    ParserKey(uint16_t compno,
             uint8_t resno,
             uint64_t precinctIndex) : compno_(compno),
                                       resno_(resno),
                                       precinctIndex_(precinctIndex)
    {
    }
     uint16_t compno_;
     uint8_t resno_;
     uint64_t precinctIndex_;
};

不过，没有明显的方式来订购钥匙。这些键可以订购吗？或者我是否需要不同的关联集合？

使用编译器资源管理器：

#include <iostream>
#include <memory>

struct test
{
  test(int i)
  {
    std::cout << "test::test("<<i<<")\n";
  }
  ~test()
  {
    std::cout << "~test()\n";
  }
};

template<>
void std::destroy_at(test* p) 
{
  std::cout<<"std::destroy_at<test>\n";
  p->~test();
}

int
main ()
{
  auto sp = std::make_shared<test>(3);
  return 33;
}

使用带有 gcc x86-64 或 clang x86-64 的 C++20 给出预期输出：

Program returned: 33
test::test(3)
std::destroy_at<test>
~test()

但 x64 msvc v19.32 给出：

Program returned: 33
test::test(3)
~test()

好像 std::destroy_at 在这里没有效果。

这是符合行为、我的误解还是 msvc 不符合或配置错误？

我有一个复杂结构的向量（此处std::pair<int, int>）。我现在想将一个成员（比如说std::pair::first）复制到一个新的向量中。有没有比这更好（更惯用）的方法

std::vector<std::pair<int, int>> list = {{1,2},{2,4},{3,6}};

std::vector<int> x_values;
x_values.reserve(list.size());
for( auto const& elem : list )
{
    x_values.emplace_back(elem.first);
}

我明白，如果没有using namespace std，而你想写一个cout，你需要有一个std::cout。

代表什么std？为什么被std广泛使用，例如std::vector、std::cout、 和std::cin？

我正在上一门课，我需要有该课的向量。我希望就地构造对象而不是使用复制构造。看来使用复制构造是不可避免的。

#include <iostream>
#include <string>
#include <vector>


class MyData {

public:
    int age;
    std::string name;

    MyData(int age, std::string name) : age(age), name(name)
    {
        std::cout << "MyData::MyData(int, std::string)\n";
    }

    MyData(const MyData& myData) : age(myData.age), name(myData.name)
    {
        std::cout << "MyData::MyData(const MyData&)\n";
    }

    MyData(MyData&& myData)
        :age(std::move(myData.age)), name(std::move(myData.name))
    {
        std::cout << "MyData::MyData(MyData&&)\n";
    }

    ~MyData() {
        std::cout << "MyData::~MyData()\n";
    }

};

#define DEBUG(...) std::cout << "Exec: " #__VA_ARGS__ << ";\n"; __VA_ARGS__ 

int main()
{

    DEBUG(std::vector<MyData> sb1);
    DEBUG(sb1.emplace_back(MyData{ 32, "SJ" }));
    DEBUG(sb1.emplace_back(MyData{ 42, "SJ" }));
} …

这段代码的工作原理：

#include <iostream>

constexpr static auto less = std::less{};

#include <string>

std::string a = "1";
std::string b = "1";

int main(){
    std::cout << ( less( 6, 3 ) ? "Y" : "N" ) << '\n';
    std::cout << ( less( a, b ) ? "Y" : "N" ) << '\n';
}

根据 en.cppreference.com，std::less 的实现如下：

template<class T>
struct Less{
    constexpr bool operator()(const T &lhs, const T &rhs) const{
        return lhs < rhs;
    }   
};

但如果这是真的，那么如何std::less{};运作呢？它将需要传递类型 -std::less<int>{};

或者，如果实现是这样的：

struct Less{ …

例如，如果我们有一个数组 A ={1, 2 , 3, 4, 5} 并且我想找到 A[i] 和 A[i+k] 之间的最大元素。我可以使用 max 函数吗？我尝试使用它，但不能。请告诉我他们是否还有其他方法可以做到这一点。

我需要这样做

vector <int> max_of_subarrays(int *arr, int n, int k)
    {
        // your code here
        vector<int> v;
        for(int i=0; i<n+1-k; i++){
            int result = arr[i];
            v.push_back(max(result,arr+k)); 
        }
        return v;

我需要动态创建一个 char[] 。我想使用 std::string 而不是直接处理 char[]，因为我不需要使用 std::string 来处理内存管理。这是我的示例代码：

int main()
{
    std::vector<char*> char_vec;
    for(size_t i = 0; i < 10; i++)
    {
        std::string s;
        s = "test" + std::to_string(i);
        char_vec.push_back(const_cast<char*>(s.c_str()));
    }

    for(auto& ele : char_vec)
    {
        std::cout << ele << std::endl;
    }
}

输出是： ，这不是我想要的。

以我的理解，循环内部创建的字符串在每次迭代中都应该是全新的，但实际上，所有字符串都使用相同的地址来存储内容。为什么会出现这种情况？我应该如何修改我的代码以实现我的目标？

感谢您的所有帮助！

2023年1月10日更新：

我根据答案尝试了以下代码：

int main()
{
    std::vector<char*> char_vec;
    std::vector<std::string> str_vec;
    for(size_t i = 0; i < 10; i++)
    {
        // str_vec.emplace_back("test" + std::to_string(i));
        str_vec.push_back("test" + std::to_string(i));
        char_vec.push_back(const_cast<char*>(str_vec.back().c_str()));
    }

    for(auto& ele : char_vec)
    {
        std::cout …

我正在尝试弄清楚如何将std函数作为参数传递。这是一个简短的例子：

#include <cmath>
#include <functional>
#include <iostream>

void bar(const double v, std::function<int(int)> foo) {
  std::cout << foo(v) << std::endl;
}

int main() {
  bar(-23., std::abs);
}

此代码无法编译，并显示消息nomatching function for call tobar，但如果删除前缀，一切正常std。这是怎么回事？