C++学习day1

已于 2023-09-01 15:00:06 修改
阅读量113 收藏
点赞数
分类专栏： c++学习 文章标签： c++ 学习 算法
于 2023-09-01 15:00:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Blue_2018/article/details/132345519
版权

1.c++的halloworld

// HelloWorld.cpp示例代码
#include <iostream>
using namespace std;
int main()
{
cout << "HelloWorld" << endl;
return 0;
}

2.c++头文件

#include <iostream>

头文件中 iostream 含义:

i : 代表输入(in);

o : 代表输出(out);

stream : 代表流 合起来则是输入输出流

C++的标准头文件无需 .h 的后缀;

C++也接收新风格后缀(如*.hpp);

例如：

        //#include <cmath>

          #include <math.h>    在c++中都可以使用

3.命名空间

using namespace std;         //命名空间

namespace stu { //代码块 }；  //末尾的" ; "可加可不加

namespace为关键字；stu为用户自定义命名，与变量名一样。

命名空间示例

#include <iostream>
using namespace std;
namespace stu //定义命名空间 名为stu
{
    void sort() //同名函数定义
    {
          cout << "stu 函数体" << endl;
    }
}
using namespace stu; //打开stu命名空间;
namespace dalao //定义命名空间 名为dalao
{
    void sort() //同名函数定义
    {
        cout << "dalao 函数体\n" << endl;
    }
}
using namespace dalao;//打开dalao命名空间;
int main()
{
    stu::sort(); //调用stu里的sort函数
    dalao::sort(); //调用dalao里的sort函数
    return 0;
}

总结：

1. 在使用命名空间时，需要先声明再使用的原则. 也有作用域的问题. 所以在打 开命名空间时，需要先对相对应的命名空间进行定义声明.

2. 在调用相同函数的时候,需要用到 :: 作用域运算符, 对同名变量及函数进行 区分, 不然系统或编译器依然无法区分；

3. 在调用命名空间内的相同变量名或函数名时，不打开命名空间也是可以的， 但是需要用作用域运算符指定某一个命名空间内的对象；

智能对象string类

定义方式 : string s;

使用该类时需要添加头文件 #include

字符串类型的本质是一个string类，该类当中包含了很多的函数接口

// 字符串的赋值
string s1 = "abdc";
//字符串的复制
string s2;
s2 = s1;
//计算str类型所占的大小 以及 所占实际长度
string s;
cin >> s;
cout << s.capacity() << endl; //所占总字节数 string类型的所占的
//字节数是根据 存放的数据动态进行调整 根据 2的N次幂动态分配
cout << s.length() << endl; //实际内容长度
//字符串的拼接
string s3;
s3 = "xyz" + s1;
s3 += "123";
//字符串的比对,可对比相等,也可以对比大于 小于 ...
string s1 = "abc";
string s2 = "abc";
if (s1 == s2)
{
cout << "相等" << endl;
}
else
{
// 字符串的赋值
string s1 = "abdc";
//字符串的复制
string s2;
s2 = s1;
//计算str类型所占的大小 以及 所占实际长度
string s;
cin >> s;
cout << s.capacity() << endl; //所占总字节数 string类型的所占的
字节数是根据 存放的数据动态进行调整 根据 2的N次幂动态分配
cout << s.length() << endl; //实际内容长度
//字符串的拼接
string s3;
s3 = "xyz" + s1;
s3 += "123";
//字符串的比对,可对比相等,也可以对比大于 小于 ...
string s1 = "abc";
string s2 = "abc";
if (s1 == s2)
{
cout << "相等" << endl;
}
else
{
cout << "不相等" << endl;
}
// 字符串中的元素引用
s1[1] = 'B'; // 将s1修改为"aBcd

引用

引用的作用： 给一个已有的对象 (变量) 取别名。

语法: 数据类型 &别名 = 原对象名

int a = 10;

int &b = a; //从此之后, a 和 b 是同一个变量,代表同一块内存.

在C语言中： typedef 是给数据类型起别名. 而引用就是给变量起别名.

本质：引用的本质在C++内部实现就是一个指针常量， 不可以改变指向，但是可以改变该地址当中的数据。

引用注意事项：

1.引用的数据类型必须要与原对象名的数据类型相匹配

2.不可对常量取引用，例如 int &r = 100; 是错误的，因为引用的本质是取别 名，而常量是匿名的。

3.引用必须在定义的同时赋值，不可单独定义引用，例如 int &r; 是错误的， 同一个变量允许多个引用.

4.引用一方面提高了数据传输的效率，另一方面简化了数据表达的样式（跟指针 相比）

5.引用一旦初始化后，就不允许被更改了，但是可以对其进行赋值操作.

6.引用本身不占用内存空间的, 它与它所引用的变量占同一份内存.

变量引用示例

#include <iostream>
using namespace std;
int main()
常量引用示例
{
// 变量起别名 int类型变量为例子，其余数据类型一样.
int a = 12;
int &c = a; /*c为变量a的别名;(声明变量a的一个引用c); 在这时,&
//号不是取地址的意义,是引用的符,也可以称为助记符 */
c = 15; //通过变量a的引用c，来改变a的值；
//查看值是否相同
cout << "a的值为:"<< a << endl;
cout << "c的值为:"<< c << endl;
//查看地址是否相同
cout << "a的地址为:"<< &a << endl;
cout << "c的地址为:"<< &c << endl;
return 0;
}

常量引用示例

#include <iostream>
using namespace std;
//常量的引用
int main()
{
const int &a = 12; //常量的引用12 ,常量引用后a的用法和12的用
法是一样的.
cout << a << endl;
return 0;
数组引用示例
}

#注意点

1.在引用常量时，需要加上const关键字进行修饰.

2.在引用常量时,是不可以对常量进行修改的.只有读权限,并没有写权限.

数组引用示例

#include <iostream>
using namespace std;
//数组的引用
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8};
int (&p)[10] = arr;
//打印数组arr的元素值
cout << "arr[0]的值" << arr[0] << endl;
cout << "arr[1]的值" << arr[1] << endl;
cout << '\n'; //换行

//打印引用数组p的元素值
cout << "p[0]的值" << p[0] << endl;
cout << "p[1]的值" << p[1] << endl;
cout << '\n'; //换行

//打印arr数组元素的地址
cout << "arr[0]的地址" << &arr[0] << endl;
cout << "arr[1]的地址" << &arr[1] << endl;
cout << '\n'; //换行

//打印引用p数组元素的地址
cout << "p[0]的地址" << &p[0] << endl;
cout << "p[1]的地址" << &p[1] << endl;
return 0;
}

 

#注意点:

1.在使用数组引用时需注意'&'号 与 '[]'的优先级问题,因为'&'号的优先级 比'[]'的优先级要低, 所以在写的时候需要添加(),让引用符号和引用名先结合在一起.

2.在使用数组引用时,引用的下标元素必须与被引用的数组下标元素个数时相同 的,不然会报错,编译时不通过.

引用当参数

作用：函数传参时，可以利用引用让形参修饰实参

优点： 1. 可以简化指针修改实参. 2. 引用当函数的参数时（形参），是不占用内存空间

#include <iostream>
using namespace std;
//引用做参数
void fun(int& a)
{
    a = 13;
    cout << "fun a的值为 :" << a << endl;
    cout << "a的地址为：" << &a <<endl;
}
//变量做参数
void fun1(int a)
{
    a = 15;
    cout << " fun 1 a的值为 :" << a << endl;
    cout << "a的地址为：" << &a <<endl;
}
//指针做参数
void fun2(int *a)
{
    *a = 16;
    cout << " fun 2 a的值为 :" << *a << endl;
    cout << "a的地址为：" << a <<endl;
}
int main()
{
    int b = 10;
    fun(b);
    cout << "调用fun之后b的值："<< b << endl;
    fun1(b);
    cout << "调用fun1之后b的值："<< b << endl;
    fun2(&b);
    cout << "调用fun2之后b的值："<< b << endl;
    return 0;
}

 

#注意点：

指针和引用属于地址传递,直接传递变量属于值传递;

地址传递: 是通过内存空间修改变量里的值. fun函数传递的是一个引用的地址,那么它其实跟我们的主函数里的变量b, 关联在了一起， 使用的是同一个内存空间,修改了fun函数里的值,则会修改主函数里的值;

值传递 : 不可以通过内存空间修改变量的值. 值传递只是在当前函数里修改变量的值,一旦这个函数调用完毕, 则栈空间里的数据将会被系统自动释放,则无法修改实参的数据；

引用当返回值

作用：引用是可以作为函数的返回值

注意点：不要返回局部变量的引用 引用作为返回值时，函数的调用可以作为左值（在等于号 的左边）；

#include <iostream>
using namespace std;
//引用做返回值
int& fun()
{
    //float a = 12.0; 注意点1
    int a = 12;
    return a; //注意点2； int &x = a;
}
int main()
{
    int &b =fun();
    cout << "b:" << b <<endl; //操作非法空间
    return 0;
}

注意点:

1.返回值类型要与变量相匹配,并且不可使用局部变量作为引用返回值；

2.当函数里的局部变量a，返回完毕之后.在主函数里使用一个引用b来接收fun函 数的结果

此时,局部变量a，已经被释放掉，在主函数中，输出b的时候,是访问非法空 间,访问非法空间的结果是不确定的

此种情况是根据编译器而言,有些编译器可以输出结果,能输出结果的时候是因 为编译器对该数据进行了保留.

但是有些编译器会出现错误,不必深究,理解以上程序的运行逻辑,原理即可.

引用与指针的区别

  1. 引用在声明时就要初始化，指针则不需要
  2. 引用初始化之后不能引用其他空间，指针可以指向其他的空间；
  3. 引用效率更高 直接操作地址 ，指针是间接操作内存地址；
  4. 引用更加安全，指针可以进行偏移；
  5. 指针相对于引用而言，更加灵活，指针更通用于 语言与 ；

类型转换

概念： 对于数据类型转换，C++完全兼容C语言的类型转换语法， 同时又新加了更合理的书写形式和更安全的新式类型转换

旧式转换 

(char)a; // C语言风格类型转换
char(a); // C++风格类型转换

新式转换

const_cast<char *>(a);
static_cast<char *>(a);
dynamic_cast<char *>(a)

新式转换是C++的全新特性，这几个转换关键字含义如下：

const_cast : 专用于去除指针或引用的 const 属性

static_cast : 与旧式转换相近，但提供了更易于查找的语法，并能有 效识别不兼容类型。

dynamic_cast : 专用于类类型的上下代际间的转换 

处理 const 类型引用

int main()
{
int i = 6; // 普通整型变量
const int &ri = i; // const型引用，不可修改
// ×: 以下语句错误
ri = 8;
// √: 去除 const 特性后，可以赋值
const_cast<int &>(ri) = 8;
}

处理常目标指针

int main()
{
    int i = 6;
    const int *p = &i; // 常目标指针p，不可修改目标
    // ×: 试图修改常指针的目标，错误！
    *p = 8;
    // √: 去除 const 特性后，可以修改其目标
    *(const_cast<int *>(p)) = 8;
    // ×: 试图扩大权限，错误！
    int *k = p;
    // √: 去除 const 特性后，可赋值给普通指针 k
    int *k = const_cast<int *>(p);
}

const_cast 可以将常目标指针的 const 属性剔除掉，但它不能剔 除普通变量和常指针本身的 const 属性。

例如

int main()
{
    int i = 6; // 普通整型变量
    int *const p = &i; // 常指针
    int j = 8;
    // ×: p是常指针，无法修改其指向
    p = &j;
    // ×: const_cast 不能去除常指针的 const 属性
    const_cast<int *>(p) = &j;
}

新式转换 static_cast

static 意味着静态转换，静态的含义是操作的过程只发生在编译阶段，而不是 运行阶段，静态转换不涉及类型推理。

以下是 static_cast 的具体用法：

int main()
{
    float f = 3.14;
    // 旧式类型转换
    int i = (int)f;
    int i = int(f);
    // 新式静态转换，等价于旧式转换:
    // 但是，新式静态强转更具可读性，更容易被查找。
    int i = static_cast<int>(f);
}

提高安全性

对于旧式类型转换，奉行了C语言的一贯作风：

基本不进行任何逻辑判定，将灵活性和责任都丢给开发者。

这样做的后果是可能会在某些比较难以察觉的地方埋下隐患，使用 static_cast 可以避免某些隐患。

int main()
{
    int i = 6; // 普通整型数据
    float *pf; // 普通浮点指针
    // 旧式转换不进行任何合理性检查
    // 下面的代码，可以将类型问题瞒天过海
    // 编译器让其畅行无阻，开发者肉眼也难以察觉
    pf = (float *)&i; // float * 与 int * 不兼容，照样通过编译
    // 使用 static_cast 遇到非兼容性类型转换，会提出警告甚至错误
    pf = static_cast<float *>(&i); // float * 与 int * 不兼容
}

虽然 static_cast 可以将不兼容的普通数据类型转换明确指出来，但对 于代际类类型的上下层转换无能为力，对于类类型的代际上行转换或下行转换，需要借助 dynamic_cast 去保证运行 的安全性。

函数提高

函数默认参数

在C++中，函数的形参列表中的形参是可以默认有值的
 

语法 :

返回值类型 函数名 (参数 = 默认值)

{
     //函数体
}


int Fun(int a,int b = 10, int c = 20)
{
    return a + b + c;
}

int Fun1(int a = 10,int b = 20)
{
    return a + b;
}

使用注意点:

如果某个位置参数有默认值,那么从这个位置开始往后，从左往右，必须都要 有默认值。

#include <iostream>
using namespace std;
int Fun(int a,int b = 10, int c = 20)
{
    return a + b + c;
}
int main()
{
    cout << Fun(5) << endl;
    //如果没有传递具体的实参数据则用默认值,如果传递了实参则使用实参的数据
   
    cout << Fun(5,20) << endl;

    return 0;
}

如果函数声明有默认值，函数实现的时候就不能有默认参数。

  1. 函数声明与函数实现只能有一个有默认值,两个不能同时有默认值。
  2. 函数声明有默认值,则函数实现不能有默认值。
  3. 函数实现有默认值,则函数声明不能有默认值。
  4. 两者只能选其一
#include <iostream>
using namespace std;
//函数声明
int Fun(int a = 10,int b = 10);
//函数实现
int Fun(int a,int b)
{
    return a + b;
}
int main()
{
    cout << Fun(20,30) << endl;
    
    return 0;
}

函数占位参数

C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该 位置

#include <iostream>
using namespace std;
//函数占位参数
void Fun(int a ,int)
{
    cout <<this is Func << endl;
}
//占位参数也可以有默认参数
void Fun1(int a ,int = 10)
{
    cout <<this is Fun1 << endl;
}
int main(void)
{
    Fun(10,10); //在调用该函数的时候,占位参数即使不用,必须填补,现阶
    //段也无法进行使用.
    Fun1(10); //占位参数有默认参数的调用方式
    return 0;
}

函数重载

概念 在C语言中，相同作用域内的重名函数会引起冲突，哪怕它们拥有不同的参数列 表也不行，

而在C++中，重名函数只要满足一定的要求，可以同时存在，这大大拓展了函数 设计的灵活性。 

这种重名且可并存的语法机制，被称为函数重载。

函数重载的作用: 函数名可以相同，提高复用性，根据函数的参数不同的情况 下，调用不同的函数。

函数重载条件

  1. 同一个作用域下
  2. 函数名称相同
  3. 函数参数类型不同 或者 参数个数不同 或者 参数顺序不同
  4. 函数的返回值不可以作为函数的重载条件
#include <iostream>
using namespace std;
//注意:以下的示例代码都是在全局作用域下进行使用的,所以他们的作用域相同
//函数重载:可以让函数名相同,提高复用性
void Func()
{
    cout << Func 的调用 << endl;
}
//参数不同示例
void Func(int a)
{
    cout << Func(int a) 的调用 << endl;
}
//参数类型不同
void Func(double a)
{
    cout << Func(double a) 的调用 << endl;
}
//以下两个示例是参数类型不同
void Func(int a, double b)
{
    cout << Func(int a, double b) 的调用 << endl;
}
void Func(double b , int a)
{
    cout << Func(double b , int a) 的调用 << endl;
}
//注意:返回值类型不同,不允许重载,并不被作为函数重载的条件
//这么写会存在二义性.如果发生调用操作系统不知道到底是调用哪个函数.
//int Func(double b , int a)
//{
// cout << "int Func(double b , int a) 的调用" << endl;
//}
int main(void)
{
    Func();
    return 0;
}

重载注意事项

引用作为重载条件 : 引用类型的参数是否可以形成重载，要根据实参的具体情况来定：

  • 如果实参为常量，那么可以重载。
  • 如果实参为变量，那么不可以重载。
#include <iostream>
using namespace std;
//引用作为重载条件
//int &a = 10; 10是一个常量,存放在常量区
//对于引用而言,引用合法的内存空间,要不是栈要不就是堆
//所以操作系统认为该调用方式是不合法的.
void Func(int &a)
{
    cout << Func(int &a) 的调用 << endl;
}
//const int &a = 10; 合法代码,因为添加const后
//该参数本身就是一个只读参数,符合要求,综合以上两点,不会出现二义性
//所以编译器会调用以下这种方式
void Func(const int &a)
{
    cout << Func(const int &a)的调用 << endl;
}
int main(void)
{
    //在系统默认的情况下,操作系统会调用可读可写的函数
    //int a = 10;
    //Func(a);
    //当参数传递的是常量的情况下,系统会默认调用加有const函数
    Func(10);
    return 0;
}

函数重载遇见默认参数

#include <iostream>
using namespace std;
//函数重载碰到默认参数
void Func(int a)
{
    cout << Func(int a)的调用 << endl;
}
void Func(int a , int b = 10)
{
    cout << Func(int a, int b = 10) 的调用 << endl;
}
int main(void)
{
    //函数重载碰到默认参数会出现二义性,以下的两个函数在不调用的情况下,
    //是可以发生重载的
    //但是一旦调用函数,有默认参数的函数可以进行调用,没有默认参数的函数
    //也可以调用
    //所以这时出现了二义性,操作系统不知道应该调用哪一个函数.
    //在写代码的时候要避免函数重载有默认参数的坑.值得注意.
    //Func(10);
    return 0;
}

堆空间的使用

概念 在C语言中，使用 malloc() 和 free() 来分配和释放堆内存，这两个函数在 C++中也一样可用， 但C++有更好的API来实现这一功能，

它们是： 

C++中利用 new 操作符在堆区开辟内存堆区开辟的内存，由程序员手动开辟 手动释放，释放利用操作符 delete

// 申请一块int型数据大小的堆内存
int *p1 = new int;

// 申请一块可以存储100个int型数据大小的堆内存
int *p2 = new int[100];

// 申请一块35个字节大小的堆内存
char *p3 = new char[35];

// 释放所有的堆内存资源
delete p1;
delete [] p2;
delete [] p3;

整型数据使用示例

#include <iostream>
using namespace std;
//1.new的基本语法
int* Fun(void)
{
    //在堆区创建整型数据并赋值为20;
    //new返回的是 该数据类型的指针.
    //你定义什么类型的数据就会返回什么类型的指针
    int *p1 = new int(20);
    return p;
}
int* Test(void)
{
    int *p = Fun();
    cout << *p << endl;
}

int main()
{
    int *p = Test();
    delete p; //释放数据
    //内存已经被释放,无法正常输出数据.
    cout << *p << endl;
    return 0;
}

数组使用示例

#include <iostream>
using namespace std;
int* Fun(void)
{
    //在堆区创建能存放十个整型数据的数组
    int *arr = new int[10];
    for (int i = 0; i < 10; i++)
    {
        arr[i] = i + 1;
    }
    return arr;
}

int main()
{
    int *p = Fun();
    for (int i = 0; i < 10; i++)
    {
         cout << *(p+i) << endl;
    }
    delete[] p; //数组在释放时,需要在delete关键字后加上[]告知编译
    //器释放的是数组.
    return 0;
}

从以上代码可以看出， new 和 delete 的语法是很简单的，

唯一需要注意的是，当分配和释放多个连续内存块，需要加上方括号 [] ;

与C语言的 malloc() 和 free() 一样， new 和 delete 只能用来管理堆内存， 不能用来操作栈内存、静态内存等其他内存空间，且在释放内存的时候只能一次性释放完毕，不允许释放一部分。

可以看到，在操作基本数据类型的时候，这两组堆内存操作函数是没有区别的， 它们真正的区别在给类对象分配内存的时候，具体而言指的是：

  • 申请类类型的内存时， new 会自动调用类的构造函数，而 malloc() / calloc() 不会。
  • 释放类类型的内存时， delete 会自动调用类的析构函数，而 free() 不会。

枚举循环

从C++11开始，C++对for语句引入了枚举循环的概念，专用于具有确定元素个数 的数组、容器或集合， 带来更加方便的操作，下面是一个简单的示例代码：

#include <iostream>
using namespace std;
int main(int argc, char const *argv[])
{
    int a[3] = {1,2,3};
    // 枚举数组a中的各个元素，并输出它们
    for(int i : a)
        cout << i << endl;
    return 0;
}

在上述代码中，i 的类型与待枚举的数 组 a 的元素类型一致， 循环的过程就是让变量 i 逐个取得数组 a 中的各个元素， 很显然，循环次数不再由程序代码指定，而是由待枚举的数据的元素个数决定。

#include <iostream>
#include <list>
using namespace std;
int main(int argc, char const *argv[])
{
    list<int> numbers;
    numbers.push_back(1);
    numbers.push_back(2);
    numbers.push_back(3);
    for(int i : numbers)
        cout << i << endl;
    return 0;
}

会飞的狗儿
关注
专栏目录
C++学习day08 ：lambda和异常捕获
qq_69809412的博客
05-24 484
C++学习第8天lambda的用法和异常捕获
Linux嵌入式开发学习 c++:day5
haogewudi666的博客
07-17 418
【私有继承】 基类的public成员和protected成员被继承后作为派生类的私有成员。 默认的继承是私有继承。 为了保证基类的部分外部接口特征能够在派生类中也存在，就必须在派生类中国重新定义同名的成员函数（重载）。 【保护继承】 基类的public和protected成员都以保护成员的身份出现在派生类中。 保护级别的成员，除了自己的类内可以访问以外，其派生类也可以访问。 【多态】 首先来看面向对象（OOP）的三大特征： 封装wrap：实现细节隐藏，使得代码模块化。把成员..
C++ —— Hello World
热门推荐
奇妙的代码
03-01 3万+
“Hello, world"程序是指在计算机屏幕上输出“Hello, world”这行字符串的计算机程序，“hello, world”的中文意思是“你好，世界。”。因为《The C Programming Language》中使用它做为第一个演示程序，非常著名，所以后来的程序员在学习编程或进行设备调试时延续了这一习惯。
【详细讲解】C++学习1--helloworld
weixin_56760882的博客
08-11 5017
之前学过python,但发现好多大佬的写的ros都是用C++写的，加之下学期要学C++,就索性学下它。（建议有C语言或其他一门语言基础的来看）参考书籍C++ Primer Plus(第六版)中文版以上就是要讲的。
由浅入深学习 C 语言：Hello World【提高篇】
最新发布
天道酬勤
08-30 1266
通过反汇编分析 Hello World 程序，析解 C 语言程序底层的工作原理。 在 C 语言，所有函数的调用，是通过栈来实现的，当函数被调用时，其返回地址、参数以及局部变量会被压入栈中。当函数返回时，这些信息会从栈中弹出，以恢复到函数被调用之前的状态。我们可以称维护所有函数调用形成的这个栈空间为函数调用栈。一个 C 程序的栈是往下生长的，即栈底在高地址，栈顶在低地址，入栈，栈顶地址会变小，出栈，栈顶地址会变大。
(C++) 01Hello World.你好，世界。
ncyyvoid的博客
07-15 1072
随手写的c++教学，主要呢也是给自己以后看着玩，能见着就不容易，先谢谢了。（风逐云墨@MVker）
2. 新建C++项目并实现HelloWorld（UnrealEngine系列教程-C++基础）
南宫的CG世界
12-10 389
实现C++的第一个程序HelloWorld
C++第一个程序：Helloworld
2301_80682565的博客
08-10 4204
为了使用后面的cout/cin/endl,我们在第一句话包含了iostream头文件，来使用iostream中的类和函数。但是发现iostream外层有个壁垒叫std,与当前域形成了隔阂，不可直接使用。故为了大量使用cout/cin且为了方便。我们直接展开std——using namespace std，这样就可以省略 std::cout 、std :: cin 、std :: endl前的endl。namespace展开后就不存在，空间中的类和函数与当前空间融合，此时若发生命名冲突，就很麻烦了。故在。
C++学习之C基础（day1）
10-02
根据给定的学习笔记内容，以下是对C语言基础知识的详细总结及解释： ### 第四章：语句 #### 4.1 空语句 - **定义**：空语句实际上仅由一个分号 `;` 构成，没有任何实际的操作。 - **示例**：`;` 或者 `int x; ;` ...
C++_Day1.zip_3D slam_C++_c++ 与slam_slam_slam案例
07-14
本资料包“C++_Day1.zip”聚焦于使用C++编程语言实现SLAM算法的实例。在3D SLAM场景下，机器人需要在未知环境中实时地确定自身位置并构建周围环境的地图。 C++是一种通用、面向对象的编程语言，因其高效性和灵活性...
零基础C++ Day 1 Hello World
08-13
输出Hello World! 代码
Hello world
11-20
C++ 首个程序Hello world。详细的介绍了代码和运行方式。
超级简单实现C++HelloWorld
04-26
超级简单实现C++HelloWorld（不用下载环境，用windows的notepad，双击即可实现）
hello world 程序
09-04
hello world 程序 hello world 程序 hello world 程序 hello world 程序 hello world 程序
C++ 程序可以定义为对象的集合
dengjuanshou7445的博客
08-01 446
C++ 基本语法C++ 程序可以定义为对象的集合，这些对象通过调用彼此的方法进行交互。现在让我们简要地看一下什么是类、对象，方法、即时变量。 对象 - 对象具有状态和行为。例如：一只狗的状态 - 颜色、名称、品种，行为 - 摇动、叫唤、吃。对象是类的实例。类 - 类可以定义为描述对象行为/状态的模板/蓝图。方法 - 从基本上说，一个方法表示一种行为。一个类可以包含多个方法。可以在方法中...
“Hello World“（给C++初学者）
yangyang110424的博客
03-23 5240
C++初学者必学的“Hello World”
C++基础一:Helloworld(入门必看)
Ziyou_Zhou的博客
11-17 4111
C++基础:Helloworld
＜C++＞快来精通C++的“Hello world“写法
qq_47882731的博客
05-11 1万+
C++是啥，命名空间，输入输出
C++初学者Day1：HalloWorld与头文件解析
"这篇文档是入门小白在学习C++第一天的笔记，主要涉及了C++的基本输入输出操作，包括iostream库的使用以及与C语言stdio.h的区别，还探讨了头文件包含的不同方式对效率的影响，以及cin和scanf，cout和printf的性能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值