C++基础知识（八）

已于 2022-01-29 09:36:46 修改
阅读量1.1k 收藏 1
点赞数
分类专栏： C++基础知识 文章标签： c++
于 2022-01-28 17:39:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43229348/article/details/122731750
版权

1.C++标准库中vector的operator[]和at()异同

  • 两者都用于访问vector中的元素
  • operator[] 不进行范围检查，at()在访问前进行范围检查
  • operator[] 越界时不抛出（未定义的行为），但 at() 越界时抛出
  • operator[]更快，at()更慢
#include <vector>
#include <iostream>
using namespace std;
int main()
{
	vector vec = {1, 2, 4};
	cout << vec.at(0)<<endl;  // 1
	cout << vec[0] << endl;  // 1
	
	cout << vec[5] << endl; // 0
	// cout << vec.at(5) <<endl; // throw error
}

2.如何在 C++ 中的 main 之前调用一些函数？

  • 方法一：
#include <iostream>
using namespace std;

void func(){cout << "inside func()" << endl;}

class Base{
public:
	Base(){func();}
};
Base b;

int main()
{
	cout << "inside main" << endl;
	return 0;
}
// inside func()
// inside main
  • 方法二：
#include <iostream>
using namespace std;

int func(){cout << "inside func()" << endl; return 100;}

class Base{
public:
	static int staticVariant;
};
int Base::staticVariant = func();

int main()
{
	cout << "inside main" << endl;
	return 0;
}
// inside func()
// inside main

3.在C和C++中的结构填充和包装

#include <iostream>
using namespace std;

struct Base
{
};
int main()
{
	cout << sizeof(Base) <<endl;
}
// 1
// 空结构体占用一个字节内存

#include <iostream>
using namespace std;

struct Base
{
char a;
char b;
};
int main()
{
	cout << sizeof(Base) <<endl;
}
// 2
// 一个char占用一个字节内存

#include <iostream>
using namespace std;

struct Base
{
char a;
short b;
};
int main()
{
	cout << sizeof(Base) <<endl;
	cout << sizeof(short) << endl;
}
// 4
// 2
// 一个char占用一个字节内存, 一个short占用2个字节内存，但需要与short对齐

#include <iostream>
using namespace std;

struct Base
{
char a;
char b;
char c;
short d;
int e;
};
int main()
{
	cout << sizeof(Base) <<endl;
	cout << sizeof(short) << endl;
	cout << sizeof(int) << endl;
}
// 12
// 2
// 4
// 一个char占用一个字节内存, 一个short占用2个字节内存，一个int占用2个字节内存，但需要对齐

#include <iostream>
using namespace std;
#pragma pack(1)
struct Base
{
char a;
char b;
char c;
short d;
int e;
};
int main()
{
	cout << sizeof(Base) <<endl;
	cout << sizeof(short) << endl;
	cout << sizeof(int) << endl;
}
// 9
// 2
// 4
// 一个char占用一个字节内存, 一个short占用2个字节内存，一个int占用2个字节内存，结果与1（#pragma pack(1)）对齐

#include <iostream>
using namespace std;
#pragma pack(2)
struct Base
{
char a;
char b;
char c;
short d;
int e;
};
int main()
{
	cout << sizeof(Base) <<endl;
	cout << sizeof(short) << endl;
	cout << sizeof(int) << endl;
}
// 9
// 2
// 4
// 一个char占用一个字节内存, 一个short占用2个字节内存，一个int占用2个字节内存，结果与1（#pragma pack(2)）对齐

#include <iostream>
using namespace std;
#pragma pack(2)
struct Base
{
char a;
char b;
char c;
short d;
char e;
short f;
int g;
};
int main()
{
	cout << sizeof(Base) <<endl;
	cout << sizeof(short) << endl;
	cout << sizeof(int) << endl;
}
// 14
// 2
// 4
// 一个char占用一个字节内存, 一个short占用2个字节内存，一个int占用2个字节内存，结果与1（#pragma pack(2)）对齐

4.C++中的显式构造函数

#include <iostream>
using namespace std;
class Base
{
private:
	int b_var;
public:
	Base(){}
	Base(int var):b_var(var){}
	void print(){cout<<b_var<<endl;}
};
void fun(Base b)
{
	b.print();
}
int main()
{
	Base obj1(10);  // 对构造函数的普通调用
	Base obj2 = 20;  // 隐式调用构造函数
	
	fun(obj1);  // 对构造函数的普通调用
	fun(30);  // 隐式调用构造函数
	return 0;
}

如果我们不想隐式调用，则如下操作：

#include <iostream>
using namespace std;
class Base
{
private:
	int b_var;
public:
	Base(){}
	explicit Base(int var):b_var(var){}
	void print(){cout<<b_var<<endl;}
};
void fun(Base b)
{
	b.print();
}
int main()
{
	Base obj1(10);  // 对构造函数的普通调用
	Base obj2 = 20;  // 隐式调用构造函数 error
	
	fun(obj1);  // 对构造函数的普通调用
	fun(30);  // 隐式调用构造函数 error
	return 0;
}

5.C++ 中的 const 成员函数

const成员函数表示不修改类的变量，如果在const成员函数中修改成员变量则会报错

#include <iostream>
using namespace std;

class Base
{
private:
	int x;
	int y;
public:
	Base(){}
	Base(int a, int b):x{a},y{b}{}
	void setX(int a){ x = a;}
	int getX() const { return x;}
	// int getX() const { x= 30;return x;}  //报错
};

int main()
{
	Base b;
	b.setX(10);
	cout << b.getX() << endl;
}

此时，如果还是想在const成员函数中修改成员变量则需要如下操作：

#include <iostream>
using namespace std;

class Base
{
private:
	mutable int x;
	int y;
public:
	Base(){}
	Base(int a, int b):x{a},y{b}{}
	void setX(int a){ x = a;}
	int getX() const { x= 30;return x;}
};

int main()
{
	Base b;
	b.setX(10);
	cout << b.getX() << endl;
}

6.std::copy和std::copy_if

以下代码使用 copy 将一个vector的内容复制到另一个vector并显示结果：

#include <algorithm>
#include <iostream>
#include <vector>
#include <iterator>
#include <numeric>
 
int main()
{
    std::vector<int> from_vector(10);
    std::iota(from_vector.begin(), from_vector.end(), 0);
 
    std::vector<int> to_vector;
    std::copy(from_vector.begin(), from_vector.end(),
              std::back_inserter(to_vector));
// 或者
//  std::vector<int> to_vector(from_vector.size());
//  std::copy(from_vector.begin(), from_vector.end(), to_vector.begin());
// 任何一种方式都相当于
//  std::vector<int> to_vector = from_vector;
 
    std::cout << "to_vector contains: ";
 	// 打印to_vector内容
    std::copy(to_vector.begin(), to_vector.end(),
              std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
 
    std::cout << "odd numbers in to_vector are: ";
 
    std::copy_if(to_vector.begin(), to_vector.end(),
                 std::ostream_iterator<int>(std::cout, " "),
                 [](int x) { return x % 2 != 0; });
    std::cout << '\n';
 
    std::cout << "to_vector contains these multiples of 3:\n";
 
    to_vector.clear();
    std::copy_if(from_vector.begin(), from_vector.end(),
                 std::back_inserter(to_vector),
                 [](int x) { return x % 3 == 0; });
 
    for (int x : to_vector)
        std::cout << x << ' ';
    std::cout << '\n';
}
/*
to_vector contains: 0 1 2 3 4 5 6 7 8 9 
odd numbers in to_vector are: 1 3 5 7 9 
to_vector contains these multiples of 3:
0 3 6 9
*/

7.对数据进行shuffle

以下代码随机打乱1~10整数 ：

#include <random>
#include <algorithm>
#include <iterator>
#include <iostream>
#include <vector>
 
int main()
{
    std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
    std::random_device rd;  // 是一个均匀分布的整数随机数生成器,该生成器产生不确定的随机数。
    std::mt19937 g(rd());  //随机数引擎
 
    std::shuffle(v.begin(), v.end(), g);
 
    std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << "\n";
}

8.std::iota

以下示例将 std::shuffle 应用于 std::list 迭代器的向量，因为 std::shuffle 不能直接应用于 std::list。 std::iota 用于填充两个容器。

#include <algorithm>
#include <iostream>
#include <list>
#include <numeric>
#include <random>
#include <vector>
 
int main()
{
    std::list<int> l(10);
    std::iota(l.begin(), l.end(), -4);
 
    std::vector<std::list<int>::iterator> v(l.size());
    std::iota(v.begin(), v.end(), l.begin());
 
    std::shuffle(v.begin(), v.end(), std::mt19937{std::random_device{}()});
 
    std::cout << "Contents of the list: ";
    for(auto n: l) std::cout << n << ' ';
    std::cout << '\n';
 
    std::cout << "Contents of the list, shuffled: ";
    for(auto i: v) std::cout << *i << ' ';
    std::cout << '\n';
}
/*
Contents of the list: -4 -3 -2 -1 0 1 2 3 4 5
Contents of the list, shuffled: 0 -1 3 4 -4 1 -2 -3 2 5
*/

9.静态成员变量和静态成员函数

#include <iostream>
using namespace std;

class Base
{
public:
	int x;
	static int y;  // 静态成员变量属于整个类
	void printX(){cout << x <<","<< y << endl;}  //普通成员函数既可以访问静态成员变量又可以访问普通变量
	static void printY(){cout << y << endl;}  // 静态成员函数只能访问静态成员变量
};

int Base::y;

int main()
{
	Base b1;
	b1.x = 10;
	Base::y = 30;
	
	Base b2;
	b2.x = 20;
	Base::y = 40;
	
	cout << b1.x << endl;
	cout << b1.y << endl;
	
	cout << b2.x << endl;
	cout << b2.y << endl;
	
	Base::printY();
	
	b1.printX();
	b1.printY();
	b2.printX();
	b2.printY();
/*
10
40
20
40
40
10,40
40
20,40
40
*/	
}

10.C++中的浅拷贝与深拷贝

  • 浅拷贝
#include <iostream>
using namespace std;

class Base
{
private:
	int * _ptr;
	int _val;
public:
	Base():_ptr{new int(0)}, _val{0}{}
	//Base(const Base& rhs)
	//{
		//_ptr = new int;
		//*_ptr = *rhs._ptr;
		//_val = rhs._val;
	//}
	void setPtr(int ptr){*_ptr=ptr;}
	void setVal(int val){_val = val;}
	int getPtr(){return *_ptr;}
	int getVal(){return _val;}
	
};

int main()
{
	Base b1;
	b1.setPtr(10);
	b1.setVal(15);
	Base b2 = b1;
	b2.setPtr(50);
	cout << "b1 ptr: " << b1.getPtr()<<endl;
	cout << "b1 val: "<< b1.getVal()<<endl;
	cout << "b2 ptr: "<< b2.getPtr()<<endl;
	cout << "b2 val: " << b2.getVal()<<endl;
	/*
	b1 ptr: 50
	b1 val: 15
	b2 ptr: 50
	b2 val: 15
	*/
}
  • 深拷贝
#include <iostream>
using namespace std;

class Base
{
private:
	int * _ptr;
	int _val;
public:
	Base():_ptr{new int(0)}, _val{0}{}
	Base(const Base& rhs)
	{
		_ptr = new int;
		*_ptr = *rhs._ptr;
		_val = rhs._val;
	}
	void setPtr(int ptr){*_ptr=ptr;}
	void setVal(int val){_val = val;}
	int getPtr(){return *_ptr;}
	int getVal(){return _val;}
	
};

int main()
{
	Base b1;
	b1.setPtr(10);
	b1.setVal(15);
	Base b2 = b1;
	b2.setPtr(50);
	cout << "b1 ptr: " << b1.getPtr()<<endl;
	cout << "b1 val: "<< b1.getVal()<<endl;
	cout << "b2 ptr: "<< b2.getPtr()<<endl;
	cout << "b2 val: " << b2.getVal()<<endl;
	/*
	b1 ptr: 10
	b1 val: 15
	b2 ptr: 50
	b2 val: 15
	*/
}
求则得之，舍则失之
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++学习笔记（七）
JIWilliams
12-05 340
时间：2018/12/5 地点：元征总部 天气：骄阳似火                                                                                                          笔记 1.basic_string和string类均提供了常规的迭代器和反向迭代器： （1）可以使用迭代器遍历string内的所...
无涯教程-C++ 向量 - at()函数
最新发布
无涯教程
06-01 356
它提供了对元素的引用。
C++练习
yayyy4的博客
08-30 305
C++,栈,队列
C++ string .at()函数的用法
热门推荐
ddpluspro的博客
04-08 2万+
string .at()用于获取指定字符 string str; cin>>str; //str=="12345" char ch; ch = str.at(0); cout<<ch; //ch=='1'; at(i),i就是想要获取的字符的下标，函数返回值为指定的字符
C++ STL:vecotr的at()函数
天道酬勤
11-16 2257
arr.at(n)与arr[n]的含义一样，返回arr中第n个元素，唯一的区别在于at()函数比[]运算符更安全，因为at()不会去访问越界的元素。可以发现at()函数在使用进行了是否越界的判断，越界则抛出异常。
在C++中，vector容器的at()成员函数用于访问容器中的元素的说明
Kegi_的博客
03-15 919
通过捕获该异常，我们可以在程序中处理越界访问的情况，并进行相应的错误处理。与operator[]不同，at()会检查索引是否越界，并在越界时抛出std::out_of_range异常。使用at()操作可以确保对vector的访问不会超出有效范围，避免了非法访问的情况。当我们需要确保访问的元素存在，并且需要处理越界的情况时，使用at()操作是非常有用的。总之，at()操作是一种安全的方式来访问vector中的元素，能够有效地避免非法访问导致的问题，并提供了对越界情况的处理机制。
c++ 使用 at()访问数组 抛出异常
阿乐的博客
12-23 684
区别在于，operator[]不做边界检查， 哪怕越界了也会返回一个引用，当然这个引用是错误的引用，如何不小心调用了这个引用对象的方法，会直接导致应用退出。而由于at会做边界检查，如果越界，会抛出异常，应用可以try catch这个异常，应用还能继续运行。当我们定义一个数组vector b(10)后，b[]和b.at()都可以对v中元素进行访问，平时一般大家使用的都是v[]这种访问方法，以至于将v.at()这种访问方式忘记了。str[] 不会检查下标越界，不会抛出异常，所以即使有错误，try 也检测不到。
c++ string的详细用法（3）at()
尔灵尔亿的博客
12-21 4717
string a="abcd"; 1.获取string字符串某一个字符 auto s=a.at(1); //结果为 s='b'; for (unsigned int i=0;i<a.size();i++) { cout << a.at(i) << endl; } /* 结果为 a b c d */ //等同于a[i],但是at()会有下标检查，如果超...
C++ vector中at的特殊用法
qq_35227495的博客
11-01 1816
C++ vector，堆中使用的注意事项
C++学习笔记（二）
关于我的学习记录
12-05 498
C++学习笔记（二）
【C++】string 之 assign、at、append函数的学习
cat_with_cat的博客
09-17 2678
【C++】string 之 assign、at、append函数的学习
c++,vector的[]和at区别
yxccc的博客
02-03 1万+
std::vector<int> a; std::cout<<a.size();上面输出是0.容器初始化什么都不做,大小为0; std::vector<int> a; // std::cout<<a.size(); a[0]=1; a.at(0)=1;下标[]赋值会显示SIGSEGV段错误,越界错误. at赋值会显示 terminate called after
std::shuffle-c++
weixin_30483697的博客
09-26 359
在Python中我们会经常看到shuffle的随机排列函数，其可以将列表中的内容进行随机排列，但在C++中却需要自己去实现这样功能的函数（c++0x之前）。在c++0x之后这样的功能函数在标准库中已有对应的提供——std::shuffle。下面就对该函数做具体的介绍： [cpp]view plaincopy template<class...
C++中vector的两种访问方式——vector[]与vector.at()的区别
m0_45388819的博客
09-25 1万+
C++中vector的两种访问方式——vector[]与vector.at()的区别 说明 当我们定义一个数组vector b(10)后，b[]和b.at()都可以对v中元素进行访问，平时一般大家使用的都是v[]这种访问方法，以至于将v.at()这种访问方式忘记了。 vector[]和vector.at()的区别 b.v[]和b.at()都可以对v中元素进行访问，并且访问的元素时都不能越界，比如a[10]或a.at(10)这样的使用会报错。区别在于，operator[]不做边界检查， 哪怕越界了也会返回一
C++基础知识（七） vector使用方法，at()用法
ljsr123的博客
03-01 1万+
Vector成员函数 函数 表述 c.assign(beg,end) 将[beg; end)区间中的数据赋值给c。 c.assign(n,elem) 将n个elem的拷贝赋值给c。 c.at(idx) 传回索引idx所指的数据，如果idx越界，抛出out_of_range。 c.back() 传回最后一个数据，不检查这个数据是否存在。 c.begin() 传回迭代器...
c++ map取值的find、[]、at方法特性对比
m0_67401920的博客
09-01 1462
项目中经常需要对std::map进行插入和取值操作，以前经常使用find和[]直接操作，c++11引入了at方法。另外，如果仅是判断元素是否存在，也可以使用count，因为map不存在重复的key，所以它的效率也可以。和数组的取值操作一样，使用中括号，由于使用简单（能少打几下键盘），很多人喜欢直接用。但如果使用错误，调试bug的时候要多打一万倍的键盘（[/捂脸]）。c11引入的at方法，用于取值，但它是进行越界检测，这会损失效率。如果存在，则返回它的值，如果不存在，则抛出异常。...
C++继承vector并重载operator[] 内部类访问外部类操作
qq_42716357的博客
03-23 1042
C++继承vector并重载operator[] 内部类访问外部类操作 const int num = 10; template<typename Type> class myVector :public std::vector<Type> { public: Type& operator[](const int i); }; template<typename Type> Type &myVector<Type>::oper
c++顺序容器vector用法
去实验室，奔跑吧
04-10 7203
原创作品转载请注明出处http://blog.csdn.net/always2015/article/details/44976729顺序容器概述一个容器就是一些特定类型的集合。顺序容器为程序员提供了控制元素存储和访问顺序的能力。这种顺序不依赖元素的值，而是与元素加入容器时的位置相对应。所有的顺序容器都提供了快速访问元素的能力。顺序容器类型有几种：vector、deque、list、forward_
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值