小编Mr.*_*cky的帖子

我想制作一个上下文对象的副本——准确地说是一个请求上下文，然后在单独的 go 例程中使用它。

问题是，如果我在context.WithCancel(reqCtx)此请求的 HTTP 处理程序完成后使用派生请求上下文，不仅原始请求上下文将被取消，而且请求上下文的副本也将被取消。

我希望能够复制原始请求上下文，并且在 HTTP 处理程序完成执行后不会被原始上下文取消。

我正在缓存文件中的一些信息,我希望能够定期检查文件的内容是否已被修改,以便我可以再次读取文件以获取新内容(如果需要).

这就是为什么我想知道是否有办法在C++中获取文件的最后修改时间.

我有两个实体 - Team和Game。一个团队可以有很多场比赛（一对多）。

所以这看起来像这样：

 public class Team
    {
        public int Id { get; set; }
        public string Name { get; set; }

        public ICollection<Game> Games { get; set; }
    }

 public class Game
    {
        public int Id { get; set; }
        public DateTime Date { get; set; }

        public int TeamId { get; set; }
        public Team Team { get; set; }
    }

这很好用，但我想通过将游戏分为两类 - 主场和客场比赛来使其更加精致。然而，这将在两个实体之间引入另一种关系，我不确定如何定义它。

我想它会是这样的吗？

 public class Team
    {
        public int Id { get; set; …

有几次我偶然发现了我有一个需要复制的指针容器的场景.

假设我们有以下类层次结构:

• 学生(基础班)

  • 新生(子类)
  • Sophmore(子类)
  • 少年(子类)
  • 高级(子类)

• StudentService

StudentService类有一个std::vector<Student*> students字段和以下构造函数:

StudentService::StudentService(std::vector<Student*> students) {
   // code
}

仅使用std::vector::operator=运算符和写入是不正确的this->students = students,因为这只会复制指针地址,因此如果外部某人删除了这些指针所指向的对象,那么StudentService类就会受到影响.

解决方案是遍历students参数中的每个指针并创建一个新的动态对象,如下所示:

for(int i = 0; i < students.size(); i++) {
   this->students.at(i) = new Student(*students.at(i));
}

但即使这样也不合适,因为它会创建ONLY Student对象.我们知道学生可以是新生,索菲尔,初中或高级.所以这是我的问题:这个问题的最佳解决方案是什么？

我想有一种方法是在每个Student类中放置一个私有枚举字段,并有4个if-else语句检查它是什么类型的Student,然后根据它创建一个新的动态对象:

 for(int i = 0; i < students.size(); i++) {
   if(students.at(i).getType() == FRESHMAN) {
      this->students.at(i) = new Freshman(*students.at(i));
   } else if(students.at(i).getType() == SOPHMORE) {
      this->students.at(i) = new Sophmore(*students.at(i));
   } else if {
   // and so on... …

我遇到了以下问题 - 每当我在Vim中编写一些C++代码并想编译并运行它时,我必须:

1. 退出插入模式
2. 使用命令保存文件 :w
3. 写入:! g++ *.cpp -o programName; ./programName以便立即编译和运行

在输入最后两个命令之后,我显然使用键盘上的上箭头键来获取最后几个命令,而不是在将来的编译和运行中一次又一次地写下它们.

但它对我来说仍然很慢.所以我想知道是否有某种方法可以创建一个键盘快捷键,输入最后两个命令,甚至可以同时完成所有这三个操作!

我正在将一个项目从 Spring Boot 1.X 迁移到 Spring Boot 2.X。唯一剩下的并且给我带来麻烦的是 Spring Boot Actuator。

在 Spring Boot 1.X 中，当您使用凭据点击/health端点时，您通常会收到更详细的指标列表，例如默认org.springframework.boot.actuate.health.DiskSpaceHealthIndicator的结果。

{ "status": "UP", "diskSpace": { "status": "UP", "total": 1000240963584, "free": 909162590208, "threshold": 10485760 } }

我还会在这里看到自定义定义的健康指标。

现在我使用了较新版本的 Actuator 库，我不再收到该附加信息（在提供凭据时）。我看到的只有：

{ "status": "UP" }

起初我以为我可能没有正确设置凭据，但是通过故意提供无效凭据，我得到了401 Unauthorized。所以它不能是身份验证。

我对调试器进行了更深入的研究，发现实际上创建了DiskSpaceHealthIndicator bean，以及我所有其他自定义定义的指标。但是似乎它们没有被 Spring Boot 注册，因为我在点击/health端点时看不到它们。

有什么建议？

如果您有一个在单个函数范围内出于某种目的临时创建的文件，并且其删除被推迟到函数结束时，那么您是否应该在删除临时文件之前关闭该临时文件，或者确实释放os.Remove()所有临时文件相关资源？

func foo() error {
    tempFile, err := os.Create(filePath)
    if err != nil {
        return err
    }
    defer func() {
        /* Is this necessary?
            if err = tempFile.Close(); err != nil {
                log.Error(err)
                return
            }
        */

        if err = os.Remove(filePath); err != nil {
            log.Error(err)
        }
    }()

    // do something

    return nil
}

我正在查看Java序列化文章,并且在try块中而不是finally块中关闭流的示例中偶然发现了很多次.有人可以向我解释为什么会这样吗？

例:

import java.io.*;
public class DeserializeDemo {

    public static void main(String [] args) {
      Employee e = null;
      try {
         FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
         ObjectInputStream in = new ObjectInputStream(fileIn);
         e = (Employee) in.readObject();
         in.close();
         fileIn.close();
      } catch(IOException i) {
         i.printStackTrace();
         return;
      } catch(ClassNotFoundException c) {
         System.out.println("Employee class not found");
         c.printStackTrace();
         return;
      }

      System.out.println("Deserialized Employee...");
      System.out.println("Name: " + e.name);
      System.out.println("Address: " + e.address);
      System.out.println("SSN: " + e.SSN);
      System.out.println("Number: " + e.number);
   }
}

资料来源:http://www.tutorialspoint.com/java/java_serialization.htm

在C++中cin,cout通常用于读取/写入标准I/O的东西.他们都被用作操作数的运营商<<和>>.换句话说,它们是我们想要所述功能时使用的对象.

由于cin和cout是对象,当一个程序的生命周期过程中,他们创建/初始化,这样我们就可以使用它们的任何地方<iostream>库导入？

我有以下任务:

"声明一个方法,期待一个Collection并在你的方法中反转它.返回给出的相同集合,不要返回一个新的集合!

static <T> void  reverse (Collection<T> collection)

不要尝试使用Collections.reverse.它仅适用于List,而不适用于集合"

我最初的想法是以下内容:

public static <T> void reverse(Collection<T> collection){

    int size = collection.size();
    Iterator<T> iter = collection.iterator();
    Iterator<T> iter2 = collection.iterator();

    for (int i = 0; i < size / 2; i++) {
        collection.add(iter.next());
        iter2.remove();
    }
}

但我不断得到奇怪的例外:

Exception in thread "main" java.lang.UnsupportedOperationException
at java.util.AbstractList.add(AbstractList.java:148)
at java.util.AbstractList.add(AbstractList.java:108)
at ReverseCollection.reverse(ReverseCollection.java:16)
at ReverseCollection.main(ReverseCollection.java:25)

知道应该怎么做吗？