STL Mutating Algorithms小结

2024-05-27 06:38
文章标签 小结 stl algorithms mutating

本文主要是介绍STL Mutating Algorithms小结,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

Non-mutating Algorithms相比,变易算法能修改容器元素数据,可进行序列数据的复制、交换、替换、填充、移除、旋转、随机抖动、分割。还是参考叶至军的那本书以及网站Cplusplus.com

copy

 

元素复制。该函数用于容器间元素拷贝,将迭代器区间[first, last)的元素复制到由复制目标迭代器result给定的区间[result, result + (last - first))

template <class InputIterator, class OutputIterator>OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result);Copies the elements in the range [first,last) into the range beginning at result.
The function returns an iterator to the end of the destination range (which points to the element following the last element copied).template<class InputIterator, class OutputIterator>OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result)
{while (first!=last) {*result = *first;++result; ++first;}return result;
}#include<iostream>
#include<algorithm>
#include<list>
#include<vector>
using namespace std;
void print(int x)
{cout<<x<<" ";
}
int main()
{vector<int> v;v.push_back(2);v.push_back(4);v.push_back(3);list<int> l(3);copy(v.begin(), v.end(), l.begin());for_each(l.begin(), l.end(), print);//2 4 3return 0;
}


 

copy_backward

反向复制。将一个迭代器区间的内容复制到另一迭代器区间,与copy()相似,不同的是复制过程从最后的元素开始。

template <class BidirectionalIterator1, class BidirectionalIterator2>BidirectionalIterator2 copy_backward (BidirectionalIterator1 first,BidirectionalIterator1 last,BidirectionalIterator2 result);
Copies the elements in the range [first,last) starting from the end into the range terminating at result.
The function returns an iterator to the first element in the destination range.template<class BidirectionalIterator1, class BidirectionalIterator2>BidirectionalIterator2 copy_backward ( BidirectionalIterator1 first,BidirectionalIterator1 last,BidirectionalIterator2 result )
{while (last!=first) *(--result) = *(--last);return result;
}#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
void print(int x)
{cout<<x<<" ";
}
int main()
{vector<int> v(4);for(int i=0;i<v.size();i++){v[i]=i+1;}vector<int> v2(8);copy_backward(v.begin(), v.end(), v2.end());for_each(v2.begin(), v2.end(), print);//0 0 0 0 1 2 3 4return 0;
}


swap

该函数的功能是实现两个元素的交换。虽然大多数容器内部都提供了swap函数,这里提供了更一般的迭代器形式。

C++98中,函数原型为:
template <class T> void swap (T& a, T& b);
C++11中,函数原型为:
template <class T> void swap (T& a, T& b)noexcept 
(is_nothrow_move_constructible<T>::value && is_nothrow_move_assignable<T>::value);
template <class T, size_t N> void swap(T (&a)[N], T (&b)[N])noexcept (noexcept(swap(*a,*b)));template <class T> void swap (T& a, T& b)
{T c(std::move(a)); a=std::move(b); b=std::move(c);
}
template <class T, size_t N> void swap (T (&a)[N], T (&b)[N])
{for (size_t i = 0; i<N; ++i) swap (a[i],b[i]);
}
//交换a,b的值
#include <iostream>     // std::cout
#include <algorithm>    // std::swap
#include <vector>       // std::vector
int main () {int x=10, y=20;                              // x:10 y:20std::swap(x,y);                              // x:20 y:10std::vector<int> foo (4,x), bar (6,y);       // foo:4x20 bar:6x10std::swap(foo,bar);                          // foo:6x10 bar:4x20std::cout << "foo contains:";for (std::vector<int>::iterator it=foo.begin(); it!=foo.end(); ++it)std::cout << ' ' << *it;return 0;
}

iter_swap

 迭代器交换。iter_swap函数是swap函数的迭代器形式,使交换算法更易用于一般的容器。

template <class ForwardIterator1, class ForwardIterator2>void iter_swap (ForwardIterator1 a, ForwardIterator2 b);
Swaps the elements pointed to by a and b.
The function calls swap (unqualified) to exchange the elements.template <class ForwardIterator1, class ForwardIterator2>void iter_swap (ForwardIterator1 a, ForwardIterator2 b)
{swap (*a, *b);
}#include <iostream>     // std::cout
#include <algorithm>    // std::iter_swap
#include <vector>       // std::vector
int main () {int myints[]={10,20,30,40,50 };              //   myints:  10  20  30  40  50std::vector<int> myvector (4,99);            // myvector:  99  99  99  99std::iter_swap(myints,myvector.begin());     //   myints: [99] 20  30  40  50// myvector: [10] 99  99  99std::iter_swap(myints+3,myvector.begin()+2); //   myints:  99  20  30 [99] 50// myvector:  10  99 [40] 99std::cout << "myvector contains:";for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)std::cout << ' ' << *it;return 0;
}

swap_ranges

区间元素交换。

函数原型如下:

template<class ForwardIterator1, class ForwardIterator2>ForwardIterator2 swap_ranges (ForwardIterator1 first1, ForwardIterator1 last1,ForwardIterator2 first2)Exchanges the values of each of the elements in the range [first1,last1) with those of their respective elements in the range beginning at first2.
The function calls swap (unqualified) to exchange the elements.template<class ForwardIterator1, class ForwardIterator2>ForwardIterator2 swap_ranges (ForwardIterator1 first1, ForwardIterator1 last1,ForwardIterator2 first2)
{while (first1!=last1) {swap (*first1, *first2);++first1; ++first2;}return first2;
}#include <iostream>     // std::cout
#include <algorithm>    // std::swap_ranges
#include <vector>       // std::vectorint main () {std::vector<int> foo (5,10);        // foo: 10 10 10 10 10std::vector<int> bar (6,33);        // bar: 33 33 33 33 33 33std::swap_ranges(foo.begin()+1, foo.end()-1, bar.begin());// print out results of swap:std::cout << "foo contains:";for (std::vector<int>::iterator it=foo.begin(); it!=foo.end(); ++it)std::cout << ' ' << *it;std::cout<<std::endl;std::cout << "bar contains:";for (std::vector<int>::iterator it=bar.begin(); it!=bar.end(); ++it)std::cout << ' ' << *it;std::cout <<std::endl;return 0;
}

transform

元素变换。该函数用于容器元素的变换操作。有两个使用原型,分别用于一元函数对象和二元函数操作。

template <class InputIterator, class OutputIterator, class UnaryOperation>OutputIterator transform (InputIterator first1, InputIterator last1,OutputIterator result, UnaryOperation op)template <class InputIterator1, class InputIterator2,class OutputIterator, class BinaryOperation>OutputIterator transform (InputIterator1 first1, InputIterator1 last1,InputIterator2 first2, OutputIterator result,BinaryOperation binary_op)Applies an operation sequentially to the elements of one (1) or two (2) ranges and stores the result in the range that begins at result.template <class InputIterator, class OutputIterator, class UnaryOperator>OutputIterator transform (InputIterator first1, InputIterator last1,OutputIterator result, UnaryOperator op)
{while (first1 != last1) {*result = op(*first1);  // or: *result=binary_op(*first1,*first2++);++result; ++first1;}return result;
}#include <iostream>     // std::cout
#include <algorithm>    // std::transform
#include <vector>       // std::vector
#include <functional>   // std::plusint op_increase (int i) { return ++i; }int main () {std::vector<int> foo;std::vector<int> bar;// set some values:for (int i=1; i<6; i++)foo.push_back (i*10);                         // foo: 10 20 30 40 50bar.resize(foo.size());                         // allocate spacestd::transform (foo.begin(), foo.end(), bar.begin(), op_increase);// bar: 11 21 31 41 51// std::plus adds together its two arguments:std::transform (foo.begin(), foo.end(), bar.begin(), foo.begin(), std::plus<int>());// foo: 21 41 61 81 101std::cout << "foo contains:";for (std::vector<int>::iterator it=foo.begin(); it!=foo.end(); ++it)std::cout << ' ' << *it;std::cout << '\n';return 0;
}

replace

替换。

template <class ForwardIterator, class T>void replace (ForwardIterator first, ForwardIterator last,const T& old_value, const T& new_value)template <class ForwardIterator, class T>void replace (ForwardIterator first, ForwardIterator last,const T& old_value, const T& new_value)
{while (first!=last) {if (*first == old_value) *first=new_value;++first;}
}#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {cout << x << " ";
}
int main(void) {vector<int> v;v.push_back(3);v.push_back(5);v.push_back(8);v.push_back(5);replace(v.begin(), v.end(), 5, 6);for_each(v.begin(), v.end(), print);//3 6 8 6return 0;
}


 

replace_if

条件替换。该函数是replace函数的谓词判断版本,将满足谓词条件的元素替换为新值。

 

template <class ForwardIterator, class UnaryPredicate, class T>void replace_if (ForwardIterator first, ForwardIterator last,UnaryPredicate pred, const T& new_value );#include <iostream>     // std::cout
#include <algorithm>    // std::replace_if
#include <vector>       // std::vectorbool IsOdd (int i) { return ((i%2)==1); }int main () {std::vector<int> myvector;// set some values:for (int i=1; i<10; i++) myvector.push_back(i);               // 1 2 3 4 5 6 7 8 9std::replace_if (myvector.begin(), myvector.end(), IsOdd, 0); // 0 2 0 4 0 6 0 8 0std::cout << "myvector contains:";for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)std::cout << ' ' << *it;std::cout << '\n';return 0;
}

replace_copy

替换和复制。该函数先进行元素替换,再将元素复制到新容器。

template <class BidirectionalIterator, class OutputIterator>OutputIterator reverse_copy (BidirectionalIterator first,BidirectionalIterator last, OutputIterator result);//将容器v中值为5的元素的值替换为6,并复制到容器v2。
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {cout << x << " ";
}
int main(void) {vector<int> v;v.push_back(3);v.push_back(5);v.push_back(8);vector<int> v2(v.size());replace_copy(v.begin(), v.end(), v2.begin(), 5, 6);for_each(v2.begin(), v2.end(), print);return 0;
}


 

replace_copy_if

条件替换和复制。该函数是replace_copy的一元谓词判断版本,用法相似。

template <class InputIterator, class OutputIterator, class UnaryPredicate, class T>OutputIterator replace_copy_if (InputIterator first, InputIterator last,OutputIterator result, UnaryPredicate pred,const T& new_value)#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {cout << x << " ";
}
int odd(int x) {return !(x % 2);
}
int main(void) {vector<int> v;v.push_back(3);v.push_back(5);v.push_back(8);vector<int> v2(v.size());replace_copy_if(v.begin(), v.end(), v2.begin(), odd, 2);for_each(v2.begin(), v2.end(), print);return 0;
}

fill

填充。该函数将同一个值填充到迭代器区间内。

template <class ForwardIterator, class T>void fill (ForwardIterator first, ForwardIterator last, const T& val)#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {cout << x << " ";
}
int main(void) {vector<int> v(5);fill(v.begin(), v.end(), 9);for_each(v.begin(), v.end(), print);return 0;
}

fill_n

n次填充。与fill函数相似,但可指定填充的元素的个数。

template <class OutputIterator, class Size, class T>void fill_n (OutputIterator first, Size n, const T& val)#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
void print(int x)
{cout<<x<<" ";
}
int main()
{vector<int> v(4);for(int i=0;i<v.size();i++)v[i]=i+1;fill_n(v.begin()+1,2,10);for_each(v.begin(),v.end(),print);//1 10 10 4return 0;
}

generate

随机生成元素。该函数用于随机生成函数,将迭代器区间内的元素填充为生成的元素。


template <class ForwardIterator, class Generator>void generate (ForwardIterator first, ForwardIterator last, Generator gen)
//生成公比为3的等比数列
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {cout << x << " ";
}
int next(int x) {return 2;
}
class Seq {
public:int a;Seq() {a = 1;}inline int operator()() {a *= 3;return a;}
};
int main(void) {vector<int> v(5);Seq seq;generate(v.begin(), v.end(), seq);for_each(v.begin(), v.end(), print);return 0;
}

generate_n

随机生成n个元素。该函数与generate相似,只是限定了填入容器的数值个数。函数原型:

template <class OutputIterator, class Size, class Generator>void generate_n (OutputIterator first, Size n, Generator gen)#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
void print(int x)
{cout<<x<<" ";
}int main()
{vector<int> v(6);generate_n(v.begin(),3, rand);for_each(v.begin(),v.end(),print);return 0;
}

remove

移除。该函数用于将容器中等于某个给定值的元素全部移除掉,并返回表示容器结束位置的迭代器。函数原型:

template <class ForwardIterator, class T>ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T& val)template <class ForwardIterator, class T>ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T& val)
{ForwardIterator result = first;while (first!=last) {if (!(*first == val)) {*result = move(*first);++result;}++first;}return result;
}
//移除数组中的元素20
#include <iostream>     // std::cout
#include <algorithm>    // std::removeint main () {int myints[] = {10,20,30,30,20,10,10,20};      // 10 20 30 30 20 10 10 20// bounds of range:int* pbegin = myints;                          // ^int* pend = myints+sizeof(myints)/sizeof(int); // ^                       ^pend = std::remove (pbegin, pend, 20);         // 10 30 30 10 10 ?  ?  ?// ^              ^std::cout << "range contains:";for (int* p=pbegin; p!=pend; ++p)std::cout << ' ' << *p;std::cout << '\n';return 0;
}

 

remove_if

条件移除。该函数是remove函数的一个带谓词判断的版本,将满足一元谓词判断条件的元素移除掉。

template <class ForwardIterator, class UnaryPredicate>ForwardIterator remove_if (ForwardIterator first, ForwardIterator last,UnaryPredicate pred)
//将容器v中值为偶数的元素移除掉
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int isOdd(int x) {return !(x % 2);
}
void print(int x) {cout << x << " ";
}
int main(void) {vector<int> v;v.push_back(3);v.push_back(7);v.push_back(8);vector<int>::iterator result =  remove_if(v.begin(), v.end(), isOdd);for_each(v.begin(), result, print);return 0;
}

remove_copy

移除复制。该函数先进行元素移除,再将元素复制到新容器,实质上是一个条件复制。

 

template <class InputIterator, class OutputIterator, class T>OutputIterator remove_copy (InputIterator first, InputIterator last,OutputIterator result, const T& val)
Copies the elements in the range [first,last) to the range beginning at result, except those elements that compare equal to val.
template <class InputIterator, class OutputIterator, class T>OutputIterator remove_copy (InputIterator first, InputIterator last,OutputIterator result, const T& val)
{while (first!=last) {if (!(*first == val)) {*result = *first;++result;}++first;}return result;
}#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int isOdd(int x) {return !(x % 2);
}
void print(int x) {cout << x << " ";
}
int main(void) {vector<int> v;v.push_back(3);v.push_back(7);v.push_back(8);vector<int>::iterator result =  remove_if(v.begin(), v.end(), isOdd);for_each(v.begin(), result, print);return 0;
}


remove_copy_if

条件移除复制。该函数是remove_copy的一个带谓词判断版本,将不满足一元谓词判断条件的元素复制到新容器。

 

template <class InputIterator, class OutputIterator, class UnaryPredicate>OutputIterator remove_copy_if (InputIterator first, InputIterator last,OutputIterator result, UnaryPredicate pred)#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int isOdd(int x) {return !(x % 2);
}
void print(int x) {cout << x << " ";
}
int main(void) {vector<int> v;v.push_back(3);v.push_back(7);v.push_back(8);vector<int> v2(5);remove_copy_if(v.begin(), v.end(), v2.begin(), isOdd);for_each(v2.begin(), v2.end(), print);return 0;
}


 unique

剔除连续重复元素。该函数用于剔除容器中连续重复的元素,只保留一个。有两个使用原型,可以使连续重复的原型,或不连续但满足二元谓词判断条件的元素。

template <class ForwardIterator>ForwardIterator unique (ForwardIterator first, ForwardIterator last)template <class ForwardIterator, class BinaryPredicate>ForwardIterator unique (ForwardIterator first, ForwardIterator last,BinaryPredicate pred)#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {cout << x << " ";
}
int main(void) {vector<int> v;v.push_back(2);v.push_back(2);v.push_back(3);v.push_back(2);v.push_back(5);vector<int>::iterator result = unique(v.begin(), v.end());for_each(v.begin(), result, print);//2 3 2 5return 0;
}

 

unique_copy

不连续重复元素复制。该函数用于复制不连续重复的元素。同样有两个使用原型。

template <class InputIterator, class OutputIterator>OutputIterator unique_copy (InputIterator first, InputIterator last,OutputIterator result)template <class InputIterator, class OutputIterator, class BinaryPredicate>OutputIterator unique_copy (InputIterator first, InputIterator last,OutputIterator result, BinaryPredicate pred)#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {cout << x << " ";
}
int main(void) {vector<int> v;v.push_back(2);v.push_back(3);v.push_back(3);v.push_back(5);v.push_back(3);vector<int> v2(4);unique_copy(v.begin(), v.end(), v2.begin());for_each(v2.begin(), v2.end(), print);//2 3 5 3return 0;
}

reverse

元素反向。该函数用于容器元素的反向排列。

template <class BidirectionalIterator>void reverse (BidirectionalIterator first, BidirectionalIterator last)#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {cout << x << " ";
}
int main(void) {vector<int> v;v.push_back(2);v.push_back(3);v.push_back(5);reverse(v.begin(), v.end());for_each(v.begin(), v.end(), print);return 0;
}

 

reverse_copy

反向复制。该函数用于反向复制容器元素。

template <class BidirectionalIterator, class OutputIterator>OutputIterator reverse_copy (BidirectionalIterator first,BidirectionalIterator last, OutputIterator result)//将容器v中的元素反向复制到新容器v2中
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {cout << x << " ";
}
int main(void) {vector<int> v;v.push_back(2);v.push_back(3);v.push_back(5);vector<int> v2(v.size());reverse_copy(v.begin(), v.end(), v2.begin());for_each(v2.begin(), v2.end(), print);return 0;
}

rotate

该函数用于旋转某个迭代器区间的元素。假设区间元素为{a0, a1, ..., ak, ..., an}akmiddle位置,则旋转复制后,新区间元素为{ak, ak+1, ..., an, a0, a1, ..., ak-1}

函数原型:

 

template <class ForwardIterator>void rotate (ForwardIterator first, ForwardIterator middle,ForwardIterator last)//将容器v以值为7的元素为支点旋转#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {cout << x << " ";
}
int main(void) {vector<int> v;for(int i = 0; i < 10; i++) {v.push_back(i + 1);}rotate(v.begin(), find(v.begin(), v.end(), 7), v.end());for_each(v.begin(), v.end(), print);return 0;
}

rotate_copy

旋转复制。该函数通过复制的方法实现旋转,比rotate函数更简单高效,但需要占用较多的内存空间。

template <class ForwardIterator, class OutputIterator>OutputIterator rotate_copy (ForwardIterator first, ForwardIterator middle,ForwardIterator last, OutputIterator result)//将以容器v中值为7的元素为支点旋转,将结果存储在容器v2中
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {cout << x << " ";
}
int main(void) {vector<int> v;for(int i = 0; i < 10; i++) {v.push_back(i + 1);}vector<int> v2(v.size());rotate_copy(v.begin(), find(v.begin(), v.end(), 7), v.end(), v2.begin());for_each(v2.begin(), v2.end(), print);return 0;
}

 

random_shuffle

随机抖动。该函数用于对容器元素进行随机的排列,有两个使用原型,使用C标准的伪随机函数rand或自定义的随机数发生器函数对象。

 

template <class RandomAccessIterator>void random_shuffle (RandomAccessIterator first, RandomAccessIterator last)template <class RandomAccessIterator, class RandomNumberGenerator>void random_shuffle (RandomAccessIterator first, RandomAccessIterator last,RandomNumberGenerator& gen)#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {cout << x << " ";
}
int main(void) {vector<int> v;for(int i = 0; i < 10; i++) {v.push_back(i);}random_shuffle(v.begin(), v.end());for_each(v.begin(), v.end(), print);cout << endl;random_shuffle(v.begin(), v.end());for_each(v.begin(), v.end(), print);return 0;
}

random_sample

随机采样。SGI C++可能不支持。

 

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
void print(int x)
{cout<<x<<" ";
}
int main()
{vector<int> v(10);for(int i=0;i<v.size();i++){v[i]=i%8;}int n=6;int iArray[n];random_sample(v.begin(),v.end(),iArray,iArray+n);cout<<"采样元素为:";for_each(iArray,iArray+n,print);cout<<endl;return 0;
}

partition

容器分割。该函数用于重新分割排列容器的元素,按照医院谓词判断条件,分割成满足和不满足条件的两部分,返回的迭代器指向首个不满足条件的元素。

 

template <class BidirectionalIterator, class UnaryPredicate>BidirectionalIterator partition (BidirectionalIterator first,BidirectionalIterator last, UnaryPredicate pred)
//将容器v中的元素分为小于5和大于等于5的两部分,并分别将元素打印出来#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {cout << x << " ";
}
int less5(int x) {if(x < 5) {return 1;} else {return 0;}
}
int main(void) {vector<int> v;for(int i = 10; i > 0; i--) {v.push_back(i);}vector<int>::iterator iv = partition(v.begin(), v.end(), less5);cout << "less than 5: ";for_each(v.begin(), iv, print);cout << endl;cout << "no less than 5: ";for_each(iv, v.end(), print);return 0;
}

stable_partition

容器稳定分割。该函数与parition类似,重新分割排列容器的元素,但可以保持原有元素的先后顺序。

 

template <class BidirectionalIterator, class UnaryPredicate>BidirectionalIterator stable_partition (BidirectionalIterator first,BidirectionalIterator last,UnaryPredicate pred)Rearranges the elements in the range [first,last), in such a way that all the elements for which pred returns true precede all those for which it returns false, and, unlike function partition, the relative order of elements within each group is preserved.
//将容器v中的元素分为小于5和大于等于5的两部分,但保持元素的稳定性
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {cout << x << " ";
}
int less5(int x) {if(x < 5) {return 1;} else {return 0;}
}
int main(void) {vector<int> v;for(int i = 10; i > 0; i--) {v.push_back(i);}vector<int>::iterator iv = stable_partition(v.begin(), v.end(), less5);cout << "less than 5: ";for_each(v.begin(), iv, print);cout << endl;cout << "no less than 5: ";for_each(iv, v.end(), print);return 0;
}

 

这篇关于STL Mutating Algorithms小结的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1006724

相关文章

Flutter打包APK的几种方式小结

《Flutter打包APK的几种方式小结》Flutter打包不同于RN,Flutter可以在AndroidStudio里编写Flutter代码并最终打包为APK,本篇主要阐述涉及到的几种打包方式,通... 目录前言1. android原生打包APK方式2. Flutter通过原生工程打包方式3. Futte

Docker镜像pull失败两种解决办法小结

《Docker镜像pull失败两种解决办法小结》有时候我们在拉取Docker镜像的过程中会遇到一些问题,:本文主要介绍Docker镜像pull失败两种解决办法的相关资料,文中通过代码介绍的非常详细... 目录docker 镜像 pull 失败解决办法1DrQwWCocker 镜像 pull 失败解决方法2总

Android Kotlin 高阶函数详解及其在协程中的应用小结

《AndroidKotlin高阶函数详解及其在协程中的应用小结》高阶函数是Kotlin中的一个重要特性,它能够将函数作为一等公民(First-ClassCitizen),使得代码更加简洁、灵活和可... 目录1. 引言2. 什么是高阶函数?3. 高阶函数的基础用法3.1 传递函数作为参数3.2 Lambda

Ollama Python 使用小结

《OllamaPython使用小结》Ollama提供了PythonSDK,使得开发者能够在Python环境中轻松集成和使用本地运行的模型进行自然语言处理任务,具有一定的参考价值,感兴趣的可以了解一... 目录安装 python SDK启动本地服务使用 Ollama 的 Python SDK 进行推理自定义客

java String.join()的使用小结

《javaString.join()的使用小结》String.join()是Java8引入的一个实用方法,用于将多个字符串按照指定分隔符连接成一个字符串,本文主要介绍了javaString.join... 目录1. 方法定义2. 基本用法2.1 拼接多个字符串2.2 拼接集合中的字符串3. 使用场景和示例3

Qt 中 isHidden 和 isVisible 的区别与使用小结

《Qt中isHidden和isVisible的区别与使用小结》Qt中的isHidden()和isVisible()方法都用于查询组件显示或隐藏状态,然而,它们有很大的区别,了解它们对于正确操... 目录1. 基础概念2. 区别清见3. 实际案例4. 注意事项5. 总结1. 基础概念Qt 中的 isHidd

SQL中的CASE WHEN用法小结

《SQL中的CASEWHEN用法小结》文章详细介绍了SQL中的CASEWHEN函数及其用法,包括简单CASEWHEN和CASEWHEN条件表达式两种形式,并通过多个实际场景展示了如何使用CASEWH... 目录一、简单CASE WHEN函数:二、CASE WHEN条件表达式函数三、常用场景场景1:不同状态展

Maven pom.xml文件中build,plugin标签的使用小结

《Mavenpom.xml文件中build,plugin标签的使用小结》本文主要介绍了Mavenpom.xml文件中build,plugin标签的使用小结,文中通过示例代码介绍的非常详细,对大家的学... 目录<build> 标签Plugins插件<build> 标签<build> 标签是 pom.XML

Spring Cloud Hystrix原理与注意事项小结

《SpringCloudHystrix原理与注意事项小结》本文介绍了Hystrix的基本概念、工作原理以及其在实际开发中的应用方式,通过对Hystrix的深入学习,开发者可以在分布式系统中实现精细... 目录一、Spring Cloud Hystrix概述和设计目标(一)Spring Cloud Hystr

Keepalived+Nginx双机配置小结

《Keepalived+Nginx双机配置小结》本文主要介绍了Keepalived+Nginx双机配置小结,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面... 目录1.1 软硬件要求1.2 部署前服务器配置调优1.3 Nginx+Keepalived部署1.3