4-C++ 中string类、bool类型、模板、array数组、vector向量的基础知识

已于 2023-04-12 20:07:46 修改
阅读量522 收藏 1
点赞数 1
文章标签： c++ 算法 开发语言
于 2023-04-12 18:33:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Summer_taotao/article/details/130099904
版权

目录

继续C++ ------3

++操作符的友元函数重载

++操作符的成员函数重载

赋值运算符重载

类型转换运算符

运算符重载注意事项

string类

bool类型的练习

模板

1.函数模板

2.类模板

练习：Compare的类模板

模板类成员函数声明和定义分离

泛型编程与STL

Array数组

vector向量

继续C++ ------3

||

++操作符的友元函数重载

#include <iostream>
using namespace std;
class Integer{  //整数类
private:
    int value;
public:
    Integer(int v):value(v){}
    friend Integer operator ++(Integer &i2);
    friend Integer operator ++(Integer &i2,int);
    void show(){
        cout<<value<<endl;
    }

};
Integer operator ++(Integer &i2){  //前置++
    cout<<"前置++"<<endl;
    //值先加 再返回
    i2.value++;
    Integer temp(i2.value);
    return temp;
    //也可以用以下方法：
    //i2.value++;
    //return i2;
}
Integer operator ++(Integer &i2,int){ //后置++
    cout<<"后置++"<<endl;
    //先返回旧值，然后再++
    Integer temp(i2.value);   //对象的旧值
    i2.value++;
    return temp;

}

int main(){
    Integer i2(10);
    (i2++).show();  //10
    i2.show(); //11
    (++i2).show();  //12

}

++操作符的成员函数重载

#include <iostream>
using namespace std;
class Integer{  //整数类
private:
    int value;
public:
    Integer(int v):value(v){}
    Integer operator ++();
    Integer operator ++(int);
    void show(){
        cout<<value<<endl;
    }

};
Integer Integer::operator ++(){  //前置++
    cout<<"前置++"<<endl;
    //值先加 再返回
    this->value++;
    return *this;   //因为this本身是个特殊的指针，所以加*取this指针的内容
}
Integer Integer::operator ++(int){ //后置++
    cout<<"后置++"<<endl;
    //先返回旧值，然后再++
    Integer temp(this->value);   //对象的旧值
    this->value++;
    return temp;

}

int main(){
    Integer i2(10);
    (i2++).show();  //10
    i2.show(); //11
    (++i2).show();  //12

}

赋值运算符重载

作用：用一个对象的值改变另一个对象的值

格式：T&operator=(const T& other)  //T可以任意类型

特点：是类内函数，只支持成员函数重载。

          如果不显示给出赋值运算符函数，会有一个默认的赋值运算符函数。

          如果当类中的属性有指针类型的时候，默认的赋值运算符函数也会引发浅拷贝问题，这时需要给出赋值运算符重载的实现。

#include <iostream>
using namespace std;
class Integer{  
private:
    int value;
public:
    Integer(int v):value(v){}
    //T& operator=(const T& other)
    Integer& operator=(const Integer& t3){
        cout<<"赋值运算符重载"<<endl;
        this->value=t3.value;
    }
    void show(){
        cout<<value<<endl;
    }
};

int main(){
    Integer i2(10);
    Integer i3(20);
    i2 = i3;
    i2.show();

}

类型转换运算符

目的：可以使自定义类型转成任意类型

特点：只支持成员函数重载

#include <iostream>
using namespace std;
class Integer{
private:
    int value;
    string str;
public:
    explicit Integer(int v,string s):value(v),str(s){}
    void show(){
        cout<<value<<endl;
    }
    operator int(){     //把类中int类型的value返回出来
        return value;
    }
    operator string(){   //把类中string类型的str返回出来
        return str;
    }
};

int main(){
    Integer i2(10,"tom");
    //Integer i3=10,tom;  explicit 屏蔽隐藏调用函数 行不通
    int a=i2;
    cout<<a<<endl;
    string s=i2;
    cout<<s<<endl;


}

运算符重载注意事项

可以被重载的运算符：

算术运算符：+、-、*、/、%、++、--

位操作运算符：&、|、~、^(位异或)、<<(左移)、>>(右移)

逻辑运算符：!、&&、||

比较运算符：<、>、>=、<=、==、!=

赋值运算符：=、+=、-=、*=、/=、%=、&=、|=、^=、<<=、>>=

其他运算符：[]、()、->、,、new、delete、new[]、delete[]

不被重载的运算符：

成员运算符 .、指针运算符 *、三目运算符 ? :、sizeof、作用域 ::

●运算符重载限制在C++已有的运算符范围内，不允许创建新的运算符。

●运算符重载也是函数重载，运算符也是函数。

●重载之后的运算符不能改变优先级和结合性。

●重载之后的运算符不能改变操作数和语法结构。

●运算符重载不能改变该运算符用于基本数据类型的含义，但是可以把基本数据类型与自定义类型一起运算，或者都使用自定义类型。

●运算符重载是针对新类型数据的实际需要对原有运算符的功能进行扩充，因此重载之后的功能应该与原有的功能类似，避免没有目的地使用运算符重载。

string类

增、删、改、插入、比较、等操作。。。

#include <iostream>
using namespace std;


int main(){
   string s1; //创建一个没有的字符
   string s2="AAA";  //相当于调用隐式构造函数
   string s3("BBB");


   //增
   string s4=s2+s3;
   cout<<s4<<endl;   //AAABBB
   s4.append("CCC");
   cout<<s4<<endl;   //AAABBBCCC
   //删
   //第一个参数为起始位置、第二个参数为个数
   s4.erase(3,3);  //AAACCC
   cout<<s4<<endl;
   //改
   s4[0]='Q';        //不用at超出范围不会报错
   cout<<s4<<endl; //QAACCC
   s4.at(0)='W';    //at超出范围会报错，at更安全
   cout<<s4<<endl; //WAACCC
   //插入
   s4.insert(1,"DDD");
   cout<<s4<<endl;   //WDDDAACCC
   //替换
   //参数：
   //第一个参数为替换的起始位置、第二个参数为替换的个数、第三个参数为新的内容
   s4.replace(1,3,"TomCat");
   cout<<s4<<endl;   //WTomCatAACCC

   //比较运算符  > < ==  !=
   //string类型 默认比较的是编码
   string s5="hello";
   string s6="hellp";
   cout<<"s5>s6:"<<(s5>s6)<<endl; //0 比较的是编码false
   //c++中有专门表示 对 或者 错 ,用bool类型，正确返回TRUE 就是1.否则返回FLOSE 就是0
   bool b=(s5>s6);
   cout<<b<<endl; //0

   //size()  length()都可以得到字符串长度
   cout<<( s5.size()==s6.size() )<<endl;  //1

   //遍历，需要c++11支持  QMAKE_CXXFLAGS += -std=c++11
   for(char ch:s5){
       cout<<ch<<" ";
   }


}

bool类型的练习

#include <iostream>

using namespace std;
bool metod(int a,int b){
    //a大于b r的值为1，否则为0
    bool r=(a>b);
    return r;
    //或者直接返回 比较结果
    //return a>b;
}

int main(){
    int m=80,n=30;
    bool re= metod(m,n);
    if(re==1){
        cout<<"m的值大于n的值"<<endl;
    }else{
        cout<<"m的值小于n的值"<<endl;
    }

}

模板

c++使用模板可以实现参数的多态化。可以让类函数声明一种通用的形式，使函数或类实现不需要具体数据类型

模板：

1.函数模板

#include <iostream>

using namespace std;
//不使用模板：
//void mySwap(int& m,int& n){
//    int t=m;
//    m=n;
//    n=t;
//}

//void mySwap(char& m,char& n){
//    int t=m;
//    m=n;
//    n=t;
//}

//交换模板：
template <typename T>
void mySwap(T& m,T& n){
    T t=m;
    m=n;
    n=t;
}
class Person{
private:
    string name;
public:
    Person(string n):name(n){}
    void show(){
        cout<<name<<endl;
    }
};

int main(){
   int a=20;
   int b=30;
   mySwap(a,b);
   cout<<a<<" "<<b<<endl;

   char ch1='A';
   char ch2='B';
   mySwap(ch1,ch2);
   cout<<ch1<<" "<<ch2<<endl;

   Person tang("唐僧");
   Person monkey("孙悟空");
   mySwap(tang,monkey);

   tang.show();
   monkey.show();

}

注意：

1.每次新的模板，模板需重新写明

2.typename和class都可以做模板形参修饰。函数模板通常用typename， 类模板用class。

3.实参类型不同时，模板形参的类型也需要不同

#include <iostream>
using namespace std;
template <typename T>     //每次新的模板 声明需要重新写明
void mySwap(T& m,T& n){
    T t=m;
    m=n;
    n=t;
}
template <typename T,typename T2>
//template <class T,class T2>
void add(T& m,T2& n){
    cout<<m+n<<endl;
}

int main(){
    int a=95,c=75;
    char b='A';
    add(a,b);
    add(a,c);

}

2.类模板

        不能通过实参类型，自动识别。需要在<>指明参数的实际类型

        Dome<string,int> student("小强"，20)；

#include <iostream>
using namespace std;
template <class T,class T2>
class Demo{
private:
    T value1;
    T2 value2;
public:
//    Demo(T n,T2 v){
//        value1=n;
//        value2=v;
//    }
    Demo(T n, T2 v):value1(n),value2(v){}
    void show(){
        cout<<value1<<" "<<value2<<endl;
    }
};

int main(){
    //不能通过实参类型自动转换
    Demo<string,int> student("小强",20);
    student.show();

    Demo<int,int> rectangle(20,30);
    rectangle.show();

}

练习：Compare的类模板

有两个私有属性 t1和t2类型相同

myMax方法可以得出 t1和t2 中的最大的值

myMin方法可以得出 t1和t2 中的最小的值

Compare<int>(5,8)c1;

c1.myMax()可以得到8

我的方法：

#include <iostream>

using namespace std;
template <class T>
class Compare{
private:
    T value;
    T value2;
public:
    Compare(T m,T n):value(m),value2(n){}
    void myMax(){
        if(value>value2){
            cout<<"Max: "<<value<<endl;
        }else{
            cout<<"Max: "<<value2<<endl;
        }

    }
    void myMin(){
        if(value2<value){
            cout<<"Min: "<<value2<<endl;
        }else{
            cout<<"Min: "<<value<<endl;
        }

    }
};

int main(){
    Compare<int> c1(5,8);
    c1.myMax();
    c1.myMin();
    Compare<string> c2("hello","hellp");
    c2.myMax();
    c2.myMin();
}

讲师方法：

#include <iostream>
using namespace std;
template <class T> //每次新的模板 声明需重名写明
class Compare{
private:
    T t1;
    T t2;
public:
    Compare(T n,T v){
        t1=n;
        t2=v;
    }
    T myMax(){
        if(t1>t2){
            return t1;
        }else{
            return t2;
        }
    }
    T myMin(){
        return t1<t2?t1:t2;
    }

};

int main()
{

    Compare<int>c1(5,8);
    cout<<"myMax():"<<c1.myMax()<<endl;
    cout<<"myMin():"<<c1.myMin()<<endl;
    
    Compare<string>c2("hello","hellp");
    cout<<c2.myMax()<<endl; //hellp
    cout<<c2.myMin()<<endl; //hello

}

模板类成员函数声明和定义分离

1.每个函数都需要加上模板和声明

2.需要用类名<>：：的方式做作用域限定符。指明它时模板类的函数

#include <iostream>
using namespace std;
//每次新的模板 声明需重名写明
template <class T>
class Compare{
private:
T t1;
T t2;
public:
Compare(T n,T v);
T myMax();
T myMin();
};

template <class T>
Compare<T>::Compare(T n,T v){
t1=n;
t2=v;
}

template <class T>
T Compare<T>::myMax(){
if(t1>t2){
return t1;
}else{
return t2;
}
}

template <class T>
T Compare<T>::myMin(){
return t1<t2?t1:t2;
}
int main()
{

Compare<int>c1(5,8);
cout<<"myMax():"<<c1.myMax()<<endl;
cout<<"myMin():"<<c1.myMin()<<endl;

Compare<string>c2("hello","hellp");
cout<<c2.myMax()<<endl; //hellp
cout<<c2.myMin()<<endl; //hello

}

泛型编程与STL

（熟悉）

       泛型编程提出的目的是：发明一种语言机制，能够实现一个标准的容器库（标准模板库 STL），标准容器库可以做到编写一般化的算法，来支持不同的数据类型。

       标准模板库（STL）是美国的惠普实验室开发的一系列软件的统称，后来被引入到C++语言中，主要包括：

  • 算法   sort()
  • 容器 : 存放数据的类模板
  • 迭代器：指示元素位置，方便算法访问操作容器

        在STL中，几乎所有的代码都采用了模板来实现，相比于传统的库，具有更好的适用性和重用性。

容器：顺序容器、关联容器

顺序容器：元素之间是顺序关系

关联容器：元素之间没有严格物理上的顺序关系，内部是有联系的

顺序容器：Array数组，vector向量，list双向链表

关联容器：map 键值对 ，mulitmap 多重键值对

Array数组

c++11引入的数组。更安全和易于使用

#include <iostream>
#include <array>

using namespace std;

int main(){
    array <int,5> a; //没有赋值，为随机值
    array <int,20>b={10,20,30};
            //前三个有赋值，后面未赋值的部分是默认值0
    for(int i:b){
        cout<<i<<" ";
    }cout<<endl;

    array <string,3> str={"AA","BB","CC"};
    str[0]="hello";
    cout<<"str.at(0):"<<str.at(0)<<endl; //hello

    for(string i:str){
        cout<<i<<endl;
    }
}

vector向量

vector向量容器是一种支持高效的随机访问和高效尾部插入新元素的容器。

向量容器一般实现为一个动态分配的数组，向量中的元素连续地存放在这个数组中

因此对向量容器进行随机访问，具有和动态访问数组类似的效率。

向量容器具有扩展容器的功能，当数组的空间不够时，向量容器对象会自动new一块更大的空间，

使用赋值运算符将原有的数据复制到新空间，并将原有空间释放。因此向量容器在每次扩展空间时，实际分配的空间一般大于所需的空间

可以高效的访问，但是插入和删除效率偏低

#include <iostream>
#include <vector>

using namespace std;

int main(){
    vector<int> v; //长度为0，空的字符串
    cout<<v.empty()<<endl;//返回值bool类型 返回1 为空
    vector<int> v2(5);   //长度为5 默认值为0
    cout<<v2.empty()<<endl;  //0
    vector<string> v3(5);  //默认空字符串
    vector<int> v4(10,1);  //10个全为1
    vector<string> v5={"AA","BB","CC"};
    vector<int> v6(v4);
    for(int i:v2){
        cout<<i<<"  ";
    }cout<<endl;      //0 0 0 0 0

    for(string i:v3){
        cout<<i<<"  ";
    }cout<<endl;       //空

    for(int i:v4){
        cout<<i<<"  ";
    }cout<<endl;     //1 1 1 1 1 1 1 1 1 1

    for(string i:v5){
        cout<<i<<"  ";
    }cout<<endl;        //AA BB CC

    for(int i:v6){
        cout<<i<<"  ";
    }cout<<endl;      //1 1 1 1 1 1 1 1 1 1
}

方法

#include <iostream>
#include <vector>

using namespace std;

int main(){
    vector<int> v; //空的
    //尾部追加
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);//1 2 3 4
    //尾部删除
    v.pop_back();//1 2 3 删除了最尾端的4

    //得到尾部和首部元素
    cout<<v.front()<<endl; //1
    cout<<v.back()<<endl;  //3

    //随机取和修改
    cout<<v[1]<<endl; //2
    cout<<v.at(1)<<endl;  //2
    v.at(0)=5;   //5 2 3

    //插入
    //v.begin() 返回第一个元素的位置
    //v.end()   返回最后一个元素的位置
    v.insert(v.begin(),4); //4 5 2 3
    v.insert(v.end(),99);  //4 5 2 3 99
    //end 指向元素最后一位的后面 即 3后面

    //删除
    v.erase(v.begin()+2);  //4 5 3 99
    //清空
    v.clear();




    for(int i:v){
        cout<<i<<"  ";
    }
}

Summer_taotao
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ vector＜vector＜int＞＞ bool数组false
weixin_44769957的博客
09-28 2823
C++ vector<vector> 如何初始化 就是 容器的每个元素又是一个容器而已 就这么简单 例如：vector<vector<int>> ivec; 插入的值类型是vector<int> 二维向量的输入问题： 不像二维数组那样，可以直接对arr[i][j]进行循环赋值。 在vector<vector>中，因为vector是一个容器， 最外层的vector容器中放着更小的vector， 而里层的vector里面放的是int型的数字。 所以我
C++ sort + vector 应用：求取数组中第K大的数( LeetCode 215. Kth Largest Element in an Array )
casgj16的博客
05-22 1053
Find the kth largest element in an unsorted array. Note that it is the kth largest element in the sorted order, not the kth distinct element.Example 1:Input: [3,2,1,5,6,4] and k = 2 Output: 5 Example ...
bool数组的理解和应用[C++]
最新发布
Q741_147的博客
07-20 452
/声明一个有五个元素的bool类型数组。
C++中的bool类型
热门推荐
bendanfly的博客
07-12 3万+
学过C语言的程序员应该清楚，在C语言中，是没有bool这个基础类型的。在C语言中，当我们要表示真或假的时候，都是定义一个非bool类型来使用的。 在C++中，加入了布尔bool这种基础的类型，用true和false来表示真或者假，也可以用非0值来表示真，用0来表示假。在C++中，虽然布尔类型只表示true和false，看起来好像可以用一个位来存储布尔类型的变量，但其实，布尔类型在C++中是占用一个...
标题关于C++ 的bool , int 数组的一个小小疑问
ccs_edseen的博客
09-12 219
标题关于C++ 的bool , int 数组的一个小小疑问： 原题是数组去重排序。用set来做更好更简便。这个分享只是一个疑问（针对去重）: 用bool数组记录遍历过的数，同样的数遍历只会让标志置为true,但在牛客网上，用例通过只有30%，不通过的用例出现了输入没有的数。 实在理解不能，不知道路过的大佬能否解答一下？是初始化错了？还是出现了什么特殊情况？ vector<int> sort_reserve(vector<int> a){ vector<int> r
【C++grammar】string类和array类
hanhan的博客
10-30 1090
C++ 使用 string 类处理字符串 string类中的函数 (1) 构造 (2) 追加 (3) 赋值 (4) 位置与清除 (5) 长度与容量 (6) 比较 (7) 子 串 (8) 搜索 (9) 运算符 C++11的string类 1、创建 string 对象 由一个字符串常量或字符串数组创建string对象 string message{ "Aloha World!" }; char charArray[] = {'H', '.
CHAPTER4 Numpy基础：数组与向量化计算（Arrays and Vectories）
m0_51775887的博客
10-28 857
CHAPTER4 Numpy Basics:Arrays and Vectories Numpy基础：数组与向量化计算 玉子呀 2020年9月 1、背景介绍（introduction） 在数值计算领域，说Numpy是python最重要的包也不为过。在numpy中有下面这些东西： nadarry,一种高效多维数组，提供了基于数组的便捷算术操作及灵活的广播功能。（broadcasting） 便利的数组函数 用于读取/写入（reading/writing）数据到磁盘的便利工具 线性代数，随机生成，傅里
C++模板类实现Vector
lx8211667846947的博客
10-16 1473
Vector<int> Vector<char> Vector<String>
C++数组模板封装
03-22
C++数组模板封装，主要成员包括： public: Array(); Array(int size); Array(int size, T value); Array(Array<T> & other); Array(T * arr, int size); Array(int size, T* arr, int arrSize); ...
C++ 简单Vector模板类
Jazz_Charles的博客
09-30 1352
刚接触类的相关内容，完成了简单的Vector模板类的项目。 用template 来实现n维向量的相关性质。 写的时候其中有几个关键的地方 1.模板类的函数定义必须和头文件放在一个cpp文件里，系统不支持模板类的单独编译。 2.定义模板类的成员（友元）函数时，都要加 template   or template 。 3.对于模板类的友元函数，都声明成了非约束（unbound）模板友元。 
c++中bool数组与bitset，vector<bool>的使用与占用空间大小对比
一个健忘症患者的记忆备份
04-24 1万+
因为最近项目中需要对一个很大的二维数组记录是否使用过一个数据，所以我就想到了操作系统中对内存块的索引的方式，采用位图可以在O(1)复制度内设置是否使用以及查找是否能够使用，但是c++中对于bool型的变量的存储是按照1个字节（8bit）存储的,造成了内存空间的浪费，由于数组可能会很大（500W+）所以我想到用bitset来实现，但是由于我的程序运行中对于这个数组大小是不确定的，需要动态去确定，所以
bool类型、string类型、引用类型
qq_46111138的博客
05-11 1017
bool类型 bool a; //a的取值只有0(false)、1(true) bool是一种整型变量 bool 形式也可以为cout<<(3<7)<<endl; bool a=true; bool a=false; 例如， bool a=true; a=35; cout<<a<<endl; // a=1 a=0; cout<<a<<endl; //a=0 第一种： b
C++学习日志24---string类和array类
taiyuezyh的博客
04-14 661
目录一、string类(字符串)二、array类(数组) 一、string类(字符串) #include<iostream> #include<string> using namespace std; int main() { //创建字符串 string s{ "Hello" }; //clear s.clear(); //用数组为字符串赋值 char arr[]{ 'W','o','r','l','d' }; s +=
C++_bool类型
WChang的博客
03-12 1681
catalogbool bool bool是占1个字节; false: 0000 0000 true: 0000 0001 对于一个bool []数组, 可以使用memset对他进行 true/false的赋值
c++中bool类型数组和int型数组的区别
m0_74153798的博客
07-31 1686
在选择使用 `bool` 类型数组还是 `int` 类型数组时，要根据具体的需求来决定。因为 `bool` 类型数组使用的是 1 bit 存储每个元素，而 `int` 类型数组占用的是 4 或 8 bytes。需要注意的是，在大多数情况下，`bool` 类型数组的长度是有限制的（通常是 8 bits），而 `int` 类型数组的长度可以是任意的。3. 取值范围：`bool` 类型的取值只能是 true 或 false，而 `int` 类型可以表示更大范围的整数，取决于该平台上 `int` 类型的字节大小。
【c++实例总结】 位运算代替bool数组
kevin的博客
12-20 919
问题：开发有时会用到多个标志位，那么通常如何实现呢？ 方式1：普通方式，即使用bool数组 方式2：二进制位方式，参考mfc等可看到一种通过使用二进制的每一位来代替bool数组的方式，比较实用 实现方式： #define MY_FLAG （1<<0） //二进制--00000001，16进制--0x00000001 #define MY_FLA...
C++扩展之：String字符串、bool类型、命名空间、域操作符
magpie_XJ的博客
11-22 451
C++扩展一、String字符串二、bool类型三、命名空间 && 域操作符 一、String字符串 在C语言中，本身不提供专门的字符串类型，通过字符数组和字符指针来处理字符串。 在C++中，它有了一个更好的解决办法，通过string类型来处理字符串 所以string就是一个类类型，它就是一个类，读者就把它看作一个类型 class basic_string{} ----> typedef basic_string string; string 是类型basic_string的别
25.指向数组的指针、指针数组与函数指针
qq_43365825的博客
12-21 242
数组指针与指针数组的区别https://www.cnblogs.com/mq0036/p/3382732.html C/C++函数指针使用总结https://www.cnblogs.com/lvchaoshun/p/7806248.html
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值