Question

我在生成随机int*并将其存储到list<int*>中时遇到一些困难。

我尝试了以下方法：

std::list<int*> generateInt(){
   std::list<int*> randomInt;

   int i = 0;

   // initialize random seed
   srand (time(NULL));

   while (i < 5){
      int* random = (int*)std::rand();
      std::cout << "Random int generated: " << random << std::endl;

      randomInt.push_back(random);
      i++;
   }

   return randomInt;
}

但是我得到如下编译问题

error: cast to pointer from integer of different size [-Werror=int-to-pointer-cast]
       int* random = (int*)std::rand();
                                     ^

我不确定我是否在这里错过了重要的事情？任何帮助或建议，将不胜感激。谢谢！

Answer 1

我能想到的最简单的方法是：

std::vector<int> generateInt(){
   std::vector<int> randomInt;

   int i = 0;

   // initialize random seed
   // srand (time(NULL)); Let that be the first line in main()

   while (i < 5){
      int random = std::rand();
      std::cout << "Random int generated: " << random << std::endl;

      randomInt.push_back(random);
      i++;
   }

   return randomInt;
}

根本不需要引入指针或std::list。

Answer 2

不要在任务中使用指针，请使用自分配器列出：）如果您需要使用简单的矿石共享ptr，则可以使用指针。如果您需要带有随机值的int prt，请使用

int* p = new int{rand()};

使用mt生成随机值（http://www.cplusplus.com/reference/random/mt19937/）并查看代码块中的注释

#include <iostream>
#include <list>
#include <random>
#include <functional>


namespace test {
    std::list<int*> __attribute__((noinline))
    foo() noexcept{
        // Mersenne Twister generator with random device seed
        // good way and not use time spec
        std::mt19937_64 generator(std::random_device{}());
        // for int gen
        // this a seporator for generated value
        std::uniform_int_distribution<> uid(0, 256);
        // make functional object to use
        auto rand_gen{std::bind(uid, generator)};

        std::list<int*> lst;
        int i{0};
        for (auto i{0}; i < 5; ++i) {
            // emplase is right way now
            try {
                lst.emplace_back(new int{rand_gen()});
            } catch (std::bad_alloc& ba) {
                std::cerr << "bad_alloc caught: " << ba.what() << std::endl;
            }
        }
        return std::move(lst);
    }
}

int main() {
    std::list<int*> lst{test::foo()};
    for(const auto& val : lst) {
        std::cout << *val << std::endl;
        delete val;
    }
    return 0;
}

如果您像Linux用户那样使用/ dev / urandom：）

Answer 3

注意：您在现实生活中不会这样做。您将使用int，可能是std::list，但更可能是std::vector的容器，而不是指向int的指针。这可能是一项使学习者在使用指针时挣扎一段时间的任务。

所以让我们处理指针并用困难的方式做到这一点。

int* random = (int*)std::rand();

表示给我一个随机数并将该随机数存储为内存地址。该地址指向什么？任何人的猜测。这是随机的。这使它成为一个坏主意。

指针必须指向相同类型的有效对象（或具有指针类型的is-a relationship），或者应将指针指向nullptr之类的“安全”停车位置，直到可以指向有效对象。对此有一些例外，但是您稍后会学习。

给予

我正在实现一个分配问题，该问题要求存储指向随机整数的指针列表。

std::list<int*> randomInt;

可能是正确的。但是...您仍然需要指向int，所以

获取有效整数，
将随机数存储为该整数中的整数，并且
将指向该整数的指针存储在list中。

那么您如何获得有效的整数？显然，您需要多个，

int number; // easy, but not enough numbers.

出局了。所有randomInt都指向同一位置，并且仅存储最后生成的值。

如果您不知道要获取多少个数字，则需要动态存储，应使用new

int * random = new int; // get an int from dynamic memory
*random = std::rand(); // generate random number and assign to int pointed at by random

（或a smart pointer（如果有）。记住一切new，您将必须delete

for (int * p:randomInt) // for all pointers in randomInt
{
    delete p; // free the memory (and other stuff you'll cover later)
}

使用完后避免内存泄漏。这非常容易出错，在仍然需要分配的情况下，缺少delete或delete的路径很容易使人发疯，因此在现实生活中请避免这样做。使用自动分配，容器和智能指针。如果不能，请拥抱RAII的力量。

在可能的情况下，由于动态内存总是要付出代价的，因此避免麻烦管理动态内存，管理智能指针或其他方式。

在这种情况下，看起来最多为五个，因此您可以创建一个数组

int numbers[5];

（但不是局部变量

std::list<int*> generateInt(){
    int numbers[5]; // do not use!!! FATAL!!!

，因为它将超出范围并在函数末尾消失，使程序充满list指向无效对象的指针）并指向数组的元素。对于一个简单的程序，您可以避免使用static局部变量

std::list<int*> generateInt(){
    static int numbers[5];

或全局变量

int numbers[5];
std::list<int*> generateInt(){

但是如果函数被多次调用该怎么办？第二个调用将破坏第一个调用的结果。这可能是可以忍受的，但是进行此调用并保证程序按预期运行的责任落在程序员身上。

我怀疑Asker打算使用new。与分配了问题的人联系，以查看他们将接受哪些其他选项。

创建指向随机生成的int的指针的列表

3 个答案: