标签: containers

我正在编写一个小模板类，它可以作为模板参数列表或向量（显然还有数据类型）。我需要重载 [ ] 运算符，为此我想使用向量的重载 [ ] 并对列表进行简单的搜索（下一个，下一个，直到我们到达所需的索引）。所以我正在检查 typeid 是否参数是列表的参数并根据这样的结果实现：

const T* operator[](size_t _index)const
{
    if(typeid(ContainerT<T,std::allocator<T> >) == typeid(vector<T>))
    {
        return m_container[_index];
    }
    else
    {
        const_iterator it = m_container.begin();
        for(int i=0;i<_index;++i)
        {
            ++it;
        }
        return *it;
    }
}

如果我不将 [ ] 用于列表，则一切正常，但是当我使用它时：

tContainer_t<int, list> list1;
cout<<list1[0]<<endl;

它根本没有编译，这是编译错误：

In file included from main.cpp:6:0:
tContainer.h: In member function ‘const T* tContainer_t<T, ContainerT>::operator[](size_t) const [with T = int, ContainerT = std::list, size_t = unsigned int]’:
main.cpp:68:9:   instantiated from here
tContainer.h:80:29: error: no match for …

我正在尝试使用 Kubernetes 创建一堆 Pod、服务和部署，但是在我运行kubectl describe命令时不断遇到以下错误。

for "POD" with RunContainerError: "runContainer: API error (500): Cannot start container bbdb58770a848733bf7130b1b230d809fcec3062b2b16748c5e4a8b12cc0533a: [8] System error: too many open files in system\n"

我已经终止了所有 pod 并尝试重新启动机器，但它并没有解决问题。我不是 Linux 专家，所以我只是想知道如何找到所有打开的文件并关闭它们？

我今天一直在思考一个问题，在google上很难找到答案。

在处理指向在堆上和堆栈上分配的对象的指针时，我试图了解 STL 容器的行为。

所以，从对象开始，没有指针......想象我有......

std::vector<int> myVec;
while(true)
{
    int myInt = 5;
    myVec.push_back(myInt);
    myVec.pop_back();
}

我的理解是 pop_back() 方法将确保删除向量中包含的整数，而不仅仅是从容器中删除。因此，如果它运行并进行了 10 亿次迭代，我不应该期望内存泄漏。我插入的所有内容都将被删除。内存检查显示了这种行为。

现在考虑我使用一个指针向量（指向堆上的对象）......

std::vector<int*> myVec;
while(true)
{
    int * myIntP = new int(5);
    myVec.push_back(myIntP);
    myVec.pop_back();
}

在这种情况下，每次调用 pop_back() 时只应删除指针本身，并且底层对象保持未删除状态，从而导致内存泄漏。因此，经过十亿次迭代后，我使用了相当多的内存，即使我的向量中没有条目。

现在，如果我有一个指针向量（指向堆栈上的对象）怎么办...

std::vector<int*> myVec;
while(true)
{
    int myInt = 5;
    int * myIntP = &myInt;
    myVec.push_back(myIntP);
    myVec.pop_back();
}

这里的指针指向堆栈对象。他们的内存是否在调用 pop_back() 时被释放？内存检查表明这种行为没有内存泄漏。使用的少量内存表明这就像堆栈上的对象一样。然而，这对我来说不是预期的，因为如果指针是从另一个函数传递给我的，则是一个堆栈变量，即

void myFunc(int * myIntP)
{
    std::vector<int*> myVec;
    myVec.push_back(myIntP);
    myVec.pop_back();
}
int main()
{
    int myInt = 5;                                                                                                                      
    int * myIntP = &myInt; …

此代码片段接收字符串、分隔符（空格）和向量作为参数，并根据分隔符拆分字符串并将其存储在向量中。如果我使用 push_back，它不会将任何内容存储到向量中，但如果我使用 [] 运算符，它就可以工作。有人可以解释为什么 push_back 不起作用吗？

void split(const string & input,char delim,vector<string> & elems){
    stringstream  ss;
    ss.str(input);
    string item;
    int i = 0;
    while(getline(ss,item,delim)){
        //elems.push_back(item);
        elems[i] = item;
        i++;
    }
}

int main(){
   char delim = ' ';
   vector<string> item(2);
   string input;
   getline(cin,input);
   split(input,delim,item);
}

我有一个 php-fpm docker 容器。php-fpm 在容器内运行，我可以在主机上获取 php-fpm 的日志吗？如果可以，怎么办？

我试图创建抽象类的向量，但它给了我编译错误。代码是：

    class Base 
    {
    public :
        int _b; 
        virtual void virtualFunc() = 0;
    };

    int _tmain(int argc, _TCHAR* argv[])
    {
        std::vector<Base> vec;
    }

我得到的编译错误是：

error C2259: 'B' : cannot instantiate abstract class due to following members:
'void B::virtualFunc(void)' : is abstract

1）我不明白为什么我会出错是因为向量会尝试调用构造函数吗？通过值传递有什么用吗？2) 模板函数的行为也一样吗？

在文件 service.yaml 我有：

parameters:
  security.allows.ip:
    - '127.0.0.1'
    - '127.0.0.2'

或者：

parameters:
  security.allows.ip: ['127.0.0.1', '127.0.0.2']

以及 DI 的配置：

services:
  _defaults:
    autowire: true
    autoconfigure: true
    public: false

我想为班级配置服务：

security.class:
    class: App\Class
    arguments:
      - '%security.allows.ip%'

最后我有消息：

无法自动装配服务“App\Class”：方法“__construct()”的参数“$securityConfiguration”必须具有类型提示或明确给出一个值。

构造函数定义是：

 public function __construct(array $securityConfiguration)

你能帮我吗？在 symfony 2.8 中它可以工作，但是对于这个配置我有这个错误。类型提示字符串的其他服务是可以的，但不适用于此类。如果我添加容器接口来构造这个类并通过 ->getParameter('security.allows.ip') 获取参数，它就可以工作。为什么？

如何使用PHP DI加载数据库容器？这是我迄今为止尝试过的变体之一。

设置.php

<?php 
use MyApp\Core\Database;
use MyApp\Models\SystemUser;

return [
    'Database'      => new Database(), 
    'SystemUser'    => new SystemUser()
];

初始化文件

$containerBuilder   = new \DI\ContainerBuilder(); 
$containerBuilder->addDefinitions('Settings.php');
$container          = $containerBuilder->build();

系统用户详细信息.php

<?php 
namespace MyApp\Models\SystemUser;

use MyApp\Core\Database;
use MyApp\Core\Config;
use MyApp\Helpers\Session;


/**
 *
 *  System User Details Class
 *
 */
class SystemUserDetails 
{

/*=================================
=            Variables            =
=================================*/

    private $db;


/*===============================
=            Methods            =
================================*/

    /**
     *
     *  Construct
     *
     */
    public function __construct(Database $db)
    {
        # Get database instance
        // …

我将我的nginx实例移至Docker容器，我想监视该容器（或其中的服务），并能够启动新容器，以防服务器重启或其他任何问题。

到目前为止，我监视容器中的nginx服务所做的工作就是在consul中添加了运行状况检查，这很好（我对consul的服务发现有所了解，不确定是那样），但是如果容器停止时，我需要一些帮助我启动新容器的方法。

我没有docker-swarm，kubernetes或其他类似的Orchestrator解决方案，但我正在考虑使用一些脚本来使用command docker run -d -p 80:80 -p 1090:1090 -v /etc/nginx/conf.d:/etc/nginx/conf.d nginx。

任何想法和建议都欢迎，谢谢。

让我们在下面假设这个类层次结构。

class BaseClass {
public:
  int x;
}

class SubClass1 : public BaseClass {
public:
  double y;
}

class SubClass2 : public BaseClass {
public:
  float z;
}
...

我想为这些类制作一个异构容器。由于子类是从基类派生的，我可以做这样的事情：

std::vector<BaseClass*> container1;

但是从 C++17 开始，我也可以std::variant这样使用：

std::vector<std::variant<SubClass1, SubClass2, ...>> container2;

使用一种或另一种的优点/缺点是什么？我对表演也很感兴趣。

考虑到我将按 对容器进行排序x，并且我还需要能够找出元素的确切类型。我要去

1. 装满容器，
2. 排序x，
3. 遍历所有元素，找出类型，相应地使用它，
4. 清除容器，然后循环重新开始。