02.C++基础

已于 2024-02-06 11:26:35 修改
阅读量320 收藏 9
点赞数 6
分类专栏： C++ 文章标签： c++
于 2024-02-03 12:57:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25023225/article/details/136006828
版权

初识

一个简单的C++程序 simple.cpp

int main()
{
    return 0;
}

运行GNU编译器编译源码

g++ -o simple simple.cpp

输入输出程序


#include <iostream>

int main()
{
	std::cout << "Enter two numbers:" << std::endl;
	int v1 = 0, v2 = 0;
	std::cin >> v1 >> v2;
	std::cout << "Sum=" << (v1 + v2) << std::endl;
	return 0;
}

注释

#include <iostream>
/*
* 读取两个数并求取它们之和
*/
int main()
{
	//提示用户输入两个数
	std::cout << "Enter two numbers:" << std::endl;
	int v1 = 0, v2 = 0;
	std::cin >> v1 >> v2;
	std::cout << "Sum=" << v1 + v2 << std::endl;
	return 0;
}

基本内置类型

C++基本内置类型

基本数据类型在内存中存储值时需要占用的内存，以及该类型的变量所能存储的最大值和最小值

typesizeminmax
bool101
char1-128127(ASCII码)
signed char1-128127
unsigned char10255
int4-21474836482147483647
signed int4-21474836482147483647
unsigned int404294967295
short int2-3276832767
signed short int2-3276832767
unsigned short int2065535
long int4-21474836482147483647
signed long int4-21474836482147483647
unsigned long int404294967295
long long int8-92233720368547758089223372036854775807
signed long long int8-92233720368547758089223372036854775807
unsigned long long int8018446744073709551615
float41.17549e-383.40282e+38
double82.22507e-3081.79769e+308
wchar_t2065535
#include <iostream>
using namespace std;
int main()
{
	cout << "|type|" << "size|min|max|" << endl;
	cout << "|----|" << "----|----|----|" << endl;
	cout << "|bool|" << sizeof(bool) << "|" << (numeric_limits<bool>::min)() << "|" << (numeric_limits<bool>::max)() << endl;
	cout << "|char|" << sizeof(char) << "|" << int((numeric_limits<char>::min)()) << "|" << int((numeric_limits<char>::max)()) << "(ASCII码)" << endl;
	cout << "|signed char|" << sizeof(signed char) << "|" << int((numeric_limits<signed char>::min)()) << "|" << int((numeric_limits<signed char>::max)()) << endl;
	cout << "|unsigned char|" << sizeof(unsigned char) << "|" << int((numeric_limits<unsigned char>::min)()) << "|" << int((numeric_limits<unsigned char>::max)()) << endl;
	cout << "|int|" << sizeof(int) << "|" << (numeric_limits<int>::min)() << "|" << (numeric_limits<int>::max)() << endl;
	cout << "|signed int|" << sizeof(signed int) << "|" << (numeric_limits<signed int>::min)() << "|" << (numeric_limits<signed int>::max)() << endl;
	cout << "|unsigned int|" << sizeof(unsigned int) << "|" << (numeric_limits<unsigned int>::min)() << "|" << (numeric_limits<unsigned int>::max)() << endl;
	cout << "|short int|" << sizeof(short int) << "|" << (numeric_limits<short int>::min)() << "|" << (numeric_limits<short int>::max)() << endl;
	cout << "|signed short int|" << sizeof(signed short int) << "|" << (numeric_limits<signed short int>::min)() << "|" << (numeric_limits<signed short int>::max)() << endl;
	cout << "|unsigned short int|" << sizeof(unsigned short int) << "|" << (numeric_limits<unsigned short int>::min)() << "|" << (numeric_limits<unsigned short int>::max)() << endl;
	cout << "|long int|" << sizeof(long int) << "|" << (numeric_limits<long int>::min)() << "|" << (numeric_limits<long int>::max)() << endl;
	cout << "|signed long int|" << sizeof(signed long int) << "|" << (numeric_limits<signed long int>::min)() << "|" << (numeric_limits<signed long int>::max)() << endl;
	cout << "|unsigned long int|" << sizeof(unsigned long int) << "|" << (numeric_limits<unsigned long int>::min)() << "|" << (numeric_limits<unsigned long int>::max)() << endl;
	cout << "|long long int|" << sizeof(long long int) << "|" << (numeric_limits< long long int>::min)() << "|" << (numeric_limits< long long int>::max)() << endl;
	cout << "|signed long long int|" << sizeof(signed long long int) << "|" << (numeric_limits<signed long long int>::min)() << "|" << (numeric_limits<signed long long int>::max)() << endl;
	cout << "|unsigned long long int|" << sizeof(unsigned long long int) << "|" << (numeric_limits<unsigned long long int>::min)() << "|" << (numeric_limits<unsigned long long int>::max)() << endl;
	cout << "|float|" << sizeof(float) << "|" << (numeric_limits<float>::min)() << "|" << (numeric_limits<float>::max)() << endl;
	cout << "|double|" << sizeof(double) << "|" << (numeric_limits<double>::min)() << "|" << (numeric_limits<double>::max)() << endl;
	cout << "|wchar_t|" << sizeof(wchar_t) << "|" << (numeric_limits<wchar_t>::min)() << "|" << (numeric_limits<wchar_t>::max)() << endl;
}

复合类型（引用、指针、数组）

左值引用

#include <iostream>
int main()
{
	int ival = 1024;
	int& refVal = ival;
	std::cout << "refVal=" << refVal << std::endl;
	refVal = 2048;
	std::cout << "ival=" << ival << std::endl;
	return 0;
}

右值引用

TODO

指针

#include <iostream>
int main()
{
	int ival = 1024;
	//获取对象地址
	int* p1 = &ival;

	int* p2 = p1;
	std::cout << "p1=" << p1 << std::endl;
	//利用指针访问对象
	std::cout << "*p1=" << *p1 << std::endl;

	//由符号*得到指针p1所值的对象，并为它赋值
	*p1 = 2204;
	std::cout << "*p1=" << *p1 << std::endl;

	//void* 指针
	//TODO

	//指向指针的指针
	int** p3 = &p1;
	std::cout << "**p3=" << **p3 << std::endl;

	//指针的引用
	int*& r = p1;
	std::cout << "*r=" << *r << std::endl;
	return 0;
}

数组

#include <iostream>
int main()
{
	int arr1[3];
	//显示初始化数组
	int arr2[3] = { 1,2,3 };
	std::string str[2] = { "hello","world" };

	//访问数组
	for (auto item : str) {
		std::cout << item << std::endl;
	}

	//指针和数组
	std::string* p1 = &str[0];
	std::cout << "*p1=" << *p1 << std::endl;
	std::string* p2 = str;//等价于 p2=&str[0]
	std::cout << "*p2=" << *p2 << std::endl;
	p2++;
	std::cout << "p2++ =" << *p2 << std::endl;
	return 0;

	//多维数组
	//TODO
}

处理类型

类型别名

#include <iostream>
int main()
{
	int i = 1;
	//类型别名
	typedef int* pint;
	pint pt= &i;
	std::cout << "*pt=" << *pt << std::endl;
	return 0;
}

结构类型

#include <iostream>
using namespace std;

struct PERSON {   // Declare PERSON struct type
    int age;   // Declare member types
    long ss;
    float weight;
    char name[25];
} family_member;   // Define object of type PERSON

struct CELL {   // Declare CELL bit field
    unsigned short character  : 8;  // 00000000 ????????
    unsigned short foreground : 3;  // 00000??? 00000000
    unsigned short intensity  : 1;  // 0000?000 00000000
    unsigned short background : 3;  // 0???0000 00000000
    unsigned short blink      : 1;  // ?0000000 00000000
} screen[25][80];       // Array of bit fields

int main() {
    struct PERSON sister;   // C style structure declaration
    PERSON brother;   // C++ style structure declaration
    sister.age = 13;   // assign values to members
    brother.age = 7;
    cout << "sister.age = " << sister.age << '\n';
    cout << "brother.age = " << brother.age << '\n';

    CELL my_cell;
    my_cell.character = 1;
    cout << "my_cell.character = " << my_cell.character;
}
// Output:
// sister.age = 13
// brother.age = 7
// my_cell.character = 1

总结：
1）由可具有不同类型的成员构成
2）其成员默认为 public，不具有封装性
相关信息，请参阅 class、union 和 enum。

变量

变量声明、定义

#include <iostream>
int main()
{
	extern int v1;//声明变量v1，而非定义v1
	int v2 = -1;//声明并定义变量v2
	return 0;
}

字面值常量

表示

#include <iostream>
int main()
{
	int i1 = 20;//20表示十进制的整数字面值常量
	int i2 = 024;//024表示八进制的整数字面值常量
	int i3 = 0x24;//024表示十六进制的整数字面值常量
	std::cout << "hello world"<<std::endl;//hello world表示字符串字面值常量
	return 0;
}

转义序列

#include <iostream>
int main()
{
	std::cout << '\115' << '\n' << std::endl;
	return 0;
}

运算符

算术运算符

在这里插入图片描述

逻辑和关系运算符

在这里插入图片描述

赋值运算符

递增、递减运算符

成员访问运算符

#include <iostream>
int main()
{
	std::string str = "hello";
	std::string* p = &str;
	std::cout << "(*p).size()=" << (*p).size() << std::endl;
	std::cout << " p->size()=" << p->size() << std::endl;
}

条件运算符

位运算符

sizeof运算符

#include <iostream>
int main()
{
	int i = 0;
	std::cout << "sizeof(i)=" << sizeof(i) << std::endl;
}

逗号运算符

#include <iostream>
int main()
{
	std::string str = "hello", str2 = "world";
	std::string* p = &str;
	std::cout << "(*p).size()=" << (*p).size() << std::endl;
	std::cout << " p->size()=" << p->size() << std::endl;
}

表达式

Lvalues 和 Rvalues（TODO）

每个 C++ 表达式是左值或右值。 左值是指在单个表达式的外部保留的对象。 可以将左值视为具有名称的对象。 所有变量（包括不能更改的 (const) 变量）都是左值。 左值是一个不在使用它的表达式的外部保留的临时值。

语句

循环语句

while循环

#include <iostream>
int main()
{
	int sum = 0, val1 = 1;
	while (val1 <= 5)
	{
		sum += val1;
		val1++;
	}
	std::cout << sum << std::endl;
	return 0;
}

for循环

#include <iostream>
int main()
{
	int sum = 0, val1 = 1;
	for (int val1 = 1; val1 <= 5; val1++) {
		sum += val1;
	}
	std::cout << sum << std::endl;
	return 0;
}

条件语句

if else语句

#include <iostream>
int main()
{
	int val = -1;
	while (val!=0)
	{
		std::cout << "请输入一个数字" << std::endl;
		std::cin >> val;
		if (val > 0) {
			std::cout << "它是正数" << std::endl;
		}
		else if (val < 0) {
			std::cout << "它是负数" << std::endl;
		}
		else {
			std::cout << "它是0" << std::endl;
		}
	}

	return 0;
}

switch语句

TODO

跳转语句

异常捕获语句

函数

函数声明、定义

#include <iostream>
//函数声明
int fact(int val);
int main()
{
	std::cout << "fact(5)=" << fact(5) << std::endl;
}

//函数定义
int fact(int val) {
	int ret = 1;
	while (val > 1) {
		ret = ret * val;
		val--;
	}
	return ret;
}

结论： 1）函数在使用之前必须先声明
2）函数声明建议在头文件中

参数传递

#include <iostream>
//函数声明，建议在头文件中声明
void reset1(int val);
void reset2(int& val);
int main()
{
	int val1 = 1;
	int val2 = 1;
	reset1(val1);
	reset2(val2);
	std::cout << " reset1(val1)=" << val1 << std::endl;//reset1(val1) = 1
	std::cout << " reset2(val2)=" << val2 << std::endl;//reset2(val2) = 0
}

//值传递
void reset1(int val) {
	val = 0;
}

//引用传递
void reset2(int& val) {
	val = 0;
}

结论： 1）值传递不影响实参的值
2）引用传递会影响实参的值

const形参和实参

#include <iostream>
//函数声明，建议在头文件中声明
void reset1(const int val);
void reset2(const int val);
void reset3(int& val);
void reset4(int& val);
int main()
{
	int val1 = 1;
	int val2 = 1;
	int val3 = 1;
	//const实参
	const int val4 = 1;
	reset1(val1);
	std::cout << " val1=" << val1 << std::endl;
	reset2(val2);
	std::cout << " val2=" << val2 << std::endl;
	reset3(val3);
	std::cout << " val3=" << val3 << std::endl;
	//reset4(val4);//error C2664: “void reset4(int &)”: 无法将参数 1 从“const int”转换为“int &”
}
//const形参
void reset1(const int val) {
	//val = 0;//error C3892: “val”: 不能给常量赋值
}

void reset2(const int val) {
}

void reset3(int& val) {
	val = 0;
}

void reset4(int& val) {
	std::cout << " val=" << val << std::endl;
}

结论：
1）const形参不可写值
2）const实参不可引用传递

数组形参

#include <iostream>
using namespace std;
//函数声明
void print(const int arr[], int size);

int main()
{
	int arr[] = { 1,2,3 };
	print(arr, end(arr) - begin(arr));
}

void print(const int arr[], int size) {
	for (int i = 0; i < size; i++) {
		cout << arr[i] << endl;
	}
}

返回值

略

命令行选项参数

main函数处理：略

函数重载

略

默认实参

略

函数指针

#include <iostream>
using namespace std;
//函数声明
bool compare(int v1, int v2);
bool (*pf)(int v1, int v2);

int main()
{
	cout << "compare(1, 2)=" << compare(1, 2) << endl;
	cout << "compare(2, 1)=" << compare(2, 1) << endl;
	pf = compare;//等同于pf = &compare;
	cout << "pf(1, 2)=" << pf(1, 2) << endl;
	cout << "pf(2, 1)=" << pf(2, 1) << endl;
}

bool compare(int v1, int v2) {
	return v1 > v2;
}

结论：
1）函数指针变量通过函数名赋值

const限定符

#include <iostream>
int main()
{
	const int bufSize = 1024;
	//bufSize = 2048;//错误：试图修改const对象的值

	//常量引用
	const int& ref = bufSize;
	std::cout << "ref=" << ref << std::endl;

	//指向常量的指针
	const int* p = &bufSize;
	std::cout << "*p=" << *p << std::endl;
	
	//指向int类型的常量指针
	int i = 0;
	int* const p1 = &i;

	//常量表达式
	const int max_files1 = bufSize + 1;
	//constexpr修改变量用来验证常量表达式（C++11）
	constexpr int max_files2 = bufSize + 1;
	return 0;
}

命名空间

#include <iostream>
//using声明
using std::cout; 
using std::endl;
int main()
{
	cout << "命名空间using" << endl;
	return 0;
}
连先森
关注
专栏目录
c++基础day02作业.txt
04-08
根据提供的文件信息，我们可以梳理出以下几个关键的知识点： ### 1....这些知识点不仅涵盖了 C++ 基础概念的应用，还涉及到了面向对象编程的基本思想，对于初学者来说是非常宝贵的实践经验和理论指导。
02_c++编程.zip
07-10
C++的基础知识包括语法、数据类型、控制结构（如if语句、for循环和while循环）、函数、数组和指针等。C++的数据类型包括基本类型（如int、float、char）和自定义类型（如类）。指针是C++的一个关键特性，允许我们...
面向对象C++：ch02 C++程序设计基础.ppt
06-12
面向对象C++：ch02 C++程序设计基础.ppt
C++零基础入门课程
10-26
2. **算法的重要性**（02 算法的重要性.mp4）：课程强调算法在编程中的核心地位，学习者应学习基础算法，如排序、搜索、递归等，并了解它们的时间复杂度和空间复杂度，以提高解决问题的效率。 3. **终端输出有颜色...
基础算法 第7章 分治算法(C++版)-2021.02.16.pdf
02-16
### 基础算法第七章：分治算法（C++版） #### 分治算法概述 分治算法是一种高效解决问题的方法，其核心思想是将一个复杂的大问题分解为若干个相似的小问题来解决，最终合并这些小问题的解得到原问题的解。这种策略...
【ARM 嵌入式 C 入门及渐进26 -- 内敛函数和宏定义的区别】
CodingCos的博客
09-25 952
在 C 语言中，内联函数和宏定义都可以用来减少函数调用的开销和提高代码执行效率，但它们在许多方面存在显著区别。内联函数使用inline关键字定义。宏定义使用#define预处理指令。无类型检查：宏是文本替换，没有类型检查，可能导致类型错误。调试困难：宏替换在预处理阶段完成，难以在调试器中跟踪宏的行为。全局作用域：宏在定义后全局有效，可能引起命名冲突和作用域污染。维护复杂：宏替换简单但容易出错，逻辑复杂时难以维护。性能优化：宏是简单的文本替换，不涉及编译器优化。return 0;
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
csdn_aspnet的专栏
09-26 1090
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
【C++】红黑树的封装——同时实现map和set
Mesar的博客
09-27 633
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
求n的阶乘的相反数（c语言）
scy2429828663的博客
09-26 401
【代码】求n的阶乘的相反数（c语言）
C语言中的日志机制：打造全面强大的日志系统
最新发布
极客代码
09-30 328
构建一个全面强大的日志机制对于软件开发至关重要。通过上述示例，你应该已经了解了如何在C语言中实现日志记录的不同方面。这种能力对于调试程序、监控应用程序状态和维护系统的稳定性非常有帮助。在软件开发中，良好的日志记录机制对于调试、监控程序状态和维护系统的稳定性至关重要。本文将介绍如何在C语言中构建一个全面强大的日志系统，并提供一些示例代码。实现日志文件的自动旋转，以便管理日志文件的大小。定义日志级别的宏，便于管理和调整日志输出。使用定义好的日志宏来记录日志。实现日志配置的读取和设置。1. 日志的基本概念。
C#测试调用Ghostscript.NET浏览PDF文件
gc_2299的博客
09-23 560
学习并测试调用Ghostscript.NET模块打开及浏览PDF文件的基本用法
简易STL实现 | Set 的实现
AsherGu的博客
09-26 437
如何使用；代码实现及其他（包括之前红黑树可以运行实现）
C++的类型转换
2401_83427936的博客
09-27 1473
在自定义类型中重载string，这里涉及到文件的写入，string的str转c_str,弄成char类型才能插入直接重载int和bool的，就支持A转int值和bool了。这里加explcit不影响转换，更支持了与其他的相反，不加explcit，A不能转double，只能转int，加了就可以了。放宽了标准C++为了加强类型转换的可视性，引入了四种命名的强制类型转换操作符：static_cast用于非多态类型的转换（静态转换），编译器隐式执行的任何类型转换都可用。
C++基础知识十
2302_80378107的博客
09-28 668
在一个string类型的字符后面插入其它的字符可以用push_back和append，这俩个是常用的。使用push_back需要注意的是参数是char型的，所以要用‘’，且里面是单个字符，不能是字符串。使用append函数时参数就是字符串用”“符号。
C/C++语言基础--C++运算符重载以及其重载限制
weixin_74085818的博客
09-27 981
运算符重载，就是赋予运算符新的含义。它是重载系统内部运算符的函数，是实现类静态多态性的方式之一。它本质上是函数重载。// 假设都属于学生类// 想要对比谁的年龄大，试想一下，能不能像正常比较大小那样直接比较呢？答案当然是可以的，这个就是我们这节课要学习的**“运算符重载”**，这样进行重载后，类更像是一种自定义数据类型。实际上，我们已经在不知不觉之中使用了运算符重载。列如：我们习惯使用的对整数，浮点数运用+、-、*、/，其实计算机对整数和浮点数的操作过程是不一样的，这个主要是整数和浮点数的。
C++中的IO流
2301_80468112的博客
09-24 676
在C语言中，如果想要将一个整形变量的数据转化为字符串格式，如何去做？1. 使用itoa()函数2. 使用sprintf()函数但是两个函数在转化时，都得需要先给出保存结果的空间，那空间要给多大呢，就不太好界定，而且转化格式不匹配时，可能还会得到错误的结果甚至程序崩溃。在C++中，可以使用stringstream类对象来避开此问题。在程序中如果想要使用stringstream，必须要包含头文件。
06.C/C++内存管理
2402_82670467的博客
09-29 824
在这里C++的内存管理相较于C作出了许多升级，下面我们就来了解一下。我们先来看一下下面的问题，温习一下C的内存分布 在 C/C++中，内存主要分为以下几个部分： 一、栈（Stack） 1. 存储内容： - 局部变量：函数内部声明的非静态变量。 - 函数参数：传递给函数的参数。 - 函数调用信息：如返回地址等。 2. 特点： - 先进后出（LIFO）的数据结构。 - 内存由编译器自动管理，当函数被调用时分配空间，函数返回时自动释放。 - 空间相对较小，通常几兆字节。 二、堆（Heap）
【C++打怪之路Lv5】-- 类和对象（下）
Sweeney_001的博客
09-29 618
类和对象(下)：初始化列表，explicit关键字、static成员、友元、内部类、匿名对象
c++ day06
yangh1231的博客
09-25 350
【代码】c++ day06。
C++语言基础入门教程
"C++语言基础" C++是C语言的扩展，它在C的基础上增加了对面向对象编程的支持，使得程序设计更加灵活且高效。C++的出现始于1980年，由贝尔实验室进行改进和扩充，目的是为了适应当时软件开发的需求。C++不仅包含了C...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值