C++基本操作笔记

一、C++ 初始化一个 size为变量的float数组

#include 

int main() {
    int arraySize;
    std::cout << "Enter the size of the array: ";
    std::cin >> arraySize;

    float* floatArray = new float[arraySize];

    // 初始化数组元素
    for (int i = 0; i < arraySize; ++i) {
        floatArray[i] = i * 0.5f; // 以0.5递增初始化数组元素
    }

    // 打印数组元素
    for (int i = 0; i < arraySize; ++i) {
        std::cout << "floatArray[" << i << "] = " << floatArray[i] << std::endl;
    }

    // 释放内存
    delete[] floatArray;

    return 0;
}

二、C++ 如何把一个少数量的float数组循环赋值给一个大的float数组

一次从连续的内存中取出5个值进行复制。这样可以提高效率，因为这种方法利用了内存中连续存储的特性。以下是示例代码：

#include 
#include 

int main() {
    const int sourceArraySize = 5;
    const int targetArraySize = 15;
    const int numSourceArrays = 3;

    float sourceArrays[numSourceArrays][sourceArraySize] = {
        {1.0, 2.0, 3.0, 4.0, 5.0},
        {6.0, 7.0, 8.0, 9.0, 10.0},
        {11.0, 12.0, 13.0, 14.0, 15.0}
    };

    float targetArray[targetArraySize];

    for (int i = 0; i < numSourceArrays; ++i) {
        const float* sourcePtr = sourceArrays[i];
        float* targetPtr = targetArray + i * sourceArraySize;

        std::copy(sourcePtr, sourcePtr + sourceArraySize, targetPtr);
    }

    // 打印目标数组的内容
    for (int i = 0; i < targetArraySize; ++i) {
        std::cout << "targetArray[" << i << "] = " << targetArray[i] << std::endl;
    }

    return 0;
}

在这个示例中，我们使用std::copy函数来从源数组中一次复制5个值到目标数组中。每次循环，我们通过sourceArrays[i]获得源数组的起始位置，然后使用指针算术运算将这5个值复制到目标数组中。

这种方式避免了使用显式的内存指针操作，提高了代码的可读性和维护性。同时，它也利用了连续的内存存储，提高了效率。

三、怎么看 数组指针指向的数组的大小

在C++中，数组指针本身并不包含有关指向的数组大小的信息。数组指针只是一个指向数组首元素的指针，它并不存储数组的大小。因此，你需要在某种方式下记录数组的大小，以便在使用数组指针时知道数组的大小。

有几种常见的方法可以实现这一点：

1. 传递数组大小作为参数： 如果你将数组传递给函数，可以将数组的大小作为参数传递给函数。这样在函数内部就可以知道数组的大小。

   void processArray(float* array, int size) {
       for (int i = 0; i < size; ++i) {
           // 处理数组元素
       }
   }
   

2. 使用标准库容器： 使用C++标准库的容器，如std::vector，可以避免直接使用数组指针，容器会自动跟踪其大小。

   #include 
   
   int main() {
       std::vector<float> array = {1.0, 2.0, 3.0, 4.0, 5.0};
       int size = array.size(); // 获取数组大小
   
       // 使用 array
       // ...
   
       return 0;
   }
   

3. 使用结构体或类： 你可以创建一个结构体或类，将数组指针和数组大小一起存储在其中。

   struct ArrayWrapper {
       float* arrayPtr;
       int size;
   };
   
   int main() {
       float myArray[] = {1.0, 2.0, 3.0, 4.0, 5.0};
       
       ArrayWrapper wrapper;
       wrapper.arrayPtr = myArray;
       wrapper.size = sizeof(myArray) / sizeof(myArray[0]);
   
       // 使用 wrapper.arrayPtr 和 wrapper.size
       // ...
   
       return 0;
   }
   

不管你选择哪种方式，都应该确保在使用数组指针时，你可以在不引发问题的情况下获取数组的大小。

四、C++ 如何计算微秒

在C++中，可以使用头文件中的std::chrono库来计算微秒。std::chrono提供了时间处理的功能，包括不同精度的时间单位。以下是一个示例代码，演示如何计算微秒：

#include 
#include 

int main() {
    // 获取当前时间点
    auto start = std::chrono::high_resolution_clock::now();

    // 模拟一些操作
    for (int i = 0; i < 1000000; ++i) {
        // 一些操作
    }

    // 获取当前时间点
    auto end = std::chrono::high_resolution_clock::now();

    // 计算时间差
    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);

    // 输出微秒
    std::cout << "Time taken: " << duration.count() << " microseconds" << std::endl;

    return 0;
}

在这个示例中，我们使用std::chrono::high_resolution_clock::now()来获取当前时间点，然后模拟一些操作，再次获取当前时间点，然后通过std::chrono::duration_cast将时间差转换为微秒。duration.count()返回微秒数。

请注意，std::chrono库提供了不同的时间单位，你可以根据需求选择适当的时间单位进行计算。

五、C++中初始化一个vector，循环的方式逐步赋值不同个数的不同数字

如果你想在一个循环中一次性初始化std::vector，逐步赋值不同个数的不同数字，你可以使用另外一种方法。以下是一个示例代码，展示了如何使用一个循环来实现这个目标：

#include 
#include 
#include  // 引入 accumulate 函数

int main() {
    std::vector<int> myVector;

    int totalNumbers = 10;
    int startValue = 1;

    for (int i = 1; i <= totalNumbers; ++i) {
        int repeatCount = i;
        int endValue = startValue + repeatCount - 1;
        
        std::vector<int> tempVector(repeatCount);
        std::iota(tempVector.begin(), tempVector.end(), startValue);

        myVector.insert(myVector.end(), tempVector.begin(), tempVector.end());

        startValue = endValue + 1;
    }

    // 打印 vector 内容
    for (int num : myVector) {
        std::cout << num << " ";
    }

    return 0;
}

在这个示例中，我们循环totalNumbers次，在每次循环中，根据当前循环变量的值，创建一个临时std::vector并使用std::iota函数填充连续的数字。然后，将临时std::vector中的元素追加到最终的myVector中。

这种方法会在一个循环中完成初始化和赋值的过程，一次性向myVector添加了不同数量的不同数字。

也可以：
std::copy 是 C++ 标准库中的一个算法，用于将一个范围内的元素复制到另一个范围。它可以用来复制数组、向量（std::vector）、列表（std::list）、字符串（std::string）等容器中的元素。

std::copy 函数的原型如下：

template<class InputIt, class OutputIt>
OutputIt copy(InputIt first, InputIt last, OutputIt d_first);

其中：

• first 和 last 是输入范围的迭代器，表示要复制的元素的起始和终止位置。
• d_first 是输出范围的迭代器，表示要将元素复制到的位置。

以下是一个示例，演示如何使用 std::copy 将一个向量中的元素复制到另一个向量中：

#include 
#include 
#include 

int main() {
    std::vector<int> source = {1, 2, 3, 4, 5};
    std::vector<int> destination;

    std::copy(source.begin(), source.end(), std::back_inserter(destination));

    std::cout << "Source: ";
    for (int num : source) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    std::cout << "Destination: ";
    for (int num : destination) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个示例中，std::copy 将 source 向量中的元素复制到 destination 向量中。std::back_inserter 是一个方便的迭代器，它允许在容器尾部插入元素。

总之，std::copy 是一个非常实用的算法，可以用于在不同容器之间复制元素，使得代码更加清晰和简洁。

六、如何看c++的变量类型

在C++中，你可以使用多种方式来查看变量的类型，这些方式有助于你了解变量的数据类型。以下是一些常见的方法：

1. 使用typeid操作符： typeid操作符可以用于获取变量的类型信息。它返回一个std::type_info对象，你可以使用name()方法来获取类型的名称。

#include 
#include 

int main() {
    int num = 42;
    const std::type_info& typeInfo = typeid(num);
    std::cout << "Variable type: " << typeInfo.name() << std::endl;
    return 0;
}

2. 使用decltype关键字： decltype关键字可以用于获取表达式的类型。它可以用于变量、函数调用、表达式等。

#include 

int main() {
    int num = 42;
    decltype(num) result = num * 2;
    std::cout << "Result type: " << typeid(result).name() << std::endl;
    return 0;
}

3. 使用typeid和模板： 你还可以使用模板函数来查看类型，这可以帮助你在编译时获得更具体的信息。

#include 
#include 

template <typename T>
void printType(const T& var) {
    std::cout << "Variable type: " << typeid(var).name() << std::endl;
}

int main() {
    int num = 42;
    printType(num);
    return 0;
}

这些方法可以帮助你查看变量的类型。但是，请注意，typeid返回的类型名称可能因编译器而异，而且在某些情况下可能不够详细。使用模板和decltype可以提供更具体的类型信息。

七、C++中 给一个 二维vector 请按vector中的内层vector的size进行从小到大的排序，并返回索引值

你可以使用自定义的比较函数来实现按照内层 vector 的大小进行排序，并返回索引值。以下是实现这一功能的示例代码：

#include 
#include 
#include 

// 比较函数，用于比较两个内层 vector 的大小
bool compareBySize(const std::vector<int>& v1, const std::vector<int>& v2) {
    return v1.size() < v2.size();
}

int main() {
    std::vector<std::vector<int>> twoDVector = {{3, 5, 8}, {1, 4}, {7, 2, 9, 6}, {0}};

    // 创建索引向量并初始化
    std::vector<size_t> indices(twoDVector.size());
    for (size_t i = 0; i < indices.size(); ++i) {
        indices[i] = i;
    }

    // 按内层 vector 的大小排序索引向量
    std::sort(indices.begin(), indices.end(), [&](size_t i, size_t j) {
        return twoDVector[i].size() < twoDVector[j].size();
    });

    // 输出排序后的索引向量
    for (size_t index : indices) {
        std::cout << "Index: " << index << ", Size: " << twoDVector[index].size() << std::endl;
    }

    return 0;
}

在这个示例中，我们首先创建了一个带有内层 vector 的二维 vector，然后使用 std::sort 函数和自定义的比较函数 compareBySize 对内层 vector 的大小进行排序。同时，我们创建了一个索引向量来保存排序后的索引，并通过 indices 向量的排序结果，输出每个索引以及对应内层 vector 的大小。

请注意，我们在 std::sort 中使用了一个 lambda 表达式，用于按照内层 vector 的大小进行排序。这个 lambda 表达式将索引 i 和 j 作为参数，然后根据内层 vector 的大小进行比较。最终的输出将显示按照内层 vector 大小排序后的索引和对应大小。