【C++】-- C++入门

已于 2022-11-10 18:56:43 修改
阅读量338 收藏 1
点赞数 2
分类专栏： C++ 文章标签： c++
于 2022-08-25 22:05:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64609308/article/details/125978805
版权

目录

1、命名空间（用于大型程序的工具）

命名空间定义

命名空间自成一个作用域

命名空间的使用

加命名空间名称及作用域限定符（::）

使用 using 将命名空间中成员引入

使用 using namespace 将命名空间名称引入

2、C++输入&输出

3、缺省参数

缺省参数概念

缺省参数分类

全缺省参数

半缺省参数

     同时有缺省参数：

      定义有缺省参数声明没有缺省参数：

4、函数重载

函数重载概念

参数列表的类型不同

参数列表的类型顺序不同

参数列表的类型个数不同

5、引用（左值引用）

引用特性

使用场景

做参数

做返回值

常引用

引用和指针的区别

引用和指针的不同点:

6、内联函数

内联函数概念

内联函数特性

inline不建议声明和定义分离，分离会导致链接错误。

7、auto关键字(C++11)

auto不能再同一行定义多个不同变量

auto不能作为函数的参数

auto不能直接用来声明数组

8、基于范围的for循环(C++11)

9、指针空值---nullptr(C++11)

1、命名空间（用于大型程序的工具）

        变量、函数和类（C++针对于C语言的结构体，所提出的优化）的名称将都存在于全局作用域中，可能会导致很多冲突。（在实际的项目中，往往会使用多个独立开发的库，这些库又会定义大量的全局名字，就会难免出现同名的情况）导致命名空间污染（namespace pollution），使用命名空间（namespace关键字）的目的是对标识符的名称进行本地化。

命名空间定义

// 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中
// 不能定义在函数或类的内部
// 1. 普通的命名空间
namespace name // name为命名空间的名称
{
        // 命名空间中的内容，既可以定义变量，也可以定义函数
        int a ;
        int Add ( int left , int right）
        {
                return left + right ;
        }
}  // 命名空间作用域后面无需加分号
// 2. 命名空间可以嵌套
namespace name_1 // name_1为命名空间的名称
{
        int a ;
        int b ;
        int Add ( int left , int right )
        {
                return left + right ;
        }
        namespace name_2  // name_2为命名空间的名称
        {
                int c ;
                int d ;
                int Sub ( int left , int right )
                {
                        return left - right ;
                }
        }
} // 命名空间作用域后面无需加分号

        和其他名字一样，命名空间的名字也必须在定义它的作用域内并需要保持唯一性。

命名空间自成一个作用域

        和其他作用域相同，每一个名称都只能出现一个唯一实体，否则即是命名冲突。不同的命名空间即作用域不同，所以在不同名的命名空间里可以有相同名字的成员。

        定义在命名空间里的名字可以被该命名空间内的成员直接访问，而位于该命名空间外的访问必须需要使用 ::（域操作符）进行明确指出所使用。

命名空间的使用

        由于命名空间自成一个作用域：

// 定义一个命名空间N
namespace N
{
        int a = 10 ;
        int b = 20 ;
        int Add ( int left , int right )
        {
                return left + right ;
        }
        int Sub ( int left , int right )
        {
                return left - right ;
        }
}
int main ()
{
        printf ( "%d\n" , a ); // 该语句编译出错，无法识别a
        return 0 ;
}

 (VS2019实现)   

  • 加命名空间名称及作用域限定符（::）

int main()
{
    printf("%d\n", N::a);
    // std::cout << N::a << std::endl;
    return 0; 
}

  • 使用 using 将命名空间中成员引入

        经常使用于，指定名空间访问+展开常用。

using N::a;
using std::cout;
using std::endl;
int main()
{
     printf("%d\n", a);
     // cout << a << endl;
     return 0; 
}

  • 使用 using namespace 将命名空间名称引入

        日常书写我们都会在文件中写上，using namespace std; 其就是对 std（C++标准库）进行引用，使用其中的函数或者对象。

using namespace std;
using namespace N;
int main()
{
    printf("%d\n", a);
    // cout << a << endl;
    printf("%d\n", b);
    // cout << b << endl;
    Add(10, 20);
    return 0; 
}

Node：

     using namespace std; 相当于直接将其空间空间内的定义在全局。

  1. 项目中，尽量不要using namespace std;

  2. 日常练习用using namespace std;

  3. 项目，指定名空间访问+展开常用

2、C++输入&输出 

#include<iostream>
using namespace std;
int main()
{
    int i;
    double d;
    cin >> i >> d; //无需指定类型，可以自动识别类型
    // << 流提取运算符

    cout << "Hello world!!!" << endl; //endl 等价于 '\n'
    // << 流插入运算符
    return 0; 
}

Note：

  1. 使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含< iostream >头文件以及std标准命名空间。（早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持<iostream.h>格式，后续编译器已不支持，因此使用<iostream> + std的方式。）
  2. 使用C++输入输出更方便，不需增加数据格式控制，比如：针对C语言的printf函数整形--需%d，字符--需%c。

不需增加数据格式控制的缺陷：

        当我们希望打出这样的字符串的地址时。

3、缺省参数

        给C++中函数的参数配备胎。

缺省参数概念

        缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参。

Note：缺省值必须是常量或者全局变量。

#include <iostream>
using namespace std;
//  int a = 0就是缺省参数
void Func(int a = 0)
{
	cout << a << endl;
}
int main()
{
	Func(); // 没有传参时，使用参数的默认值
	Func(10); // 传参时，使用指定的实参
}

缺省参数分类

  • 全缺省参数

#include <iostream>
using namespace std;
void Func(int a = 0, int b = 0, int c = 0)
{
	cout << a << ' ' << b << ' ' << c << endl;
}
int main()
{
	Func(); // 没有传参时，使用参数的默认值
	Func(10);
	Func(10, 20); //传参是从左往右给（对于Func：先a 再b 然后c）
	Func(10, 20, 30);
}

Note：C++规定，不允许跨越传递。

  • 半缺省参数

       缺省部分参数。

#include <iostream>
using namespace std;
void Func(int a, int b = 0, int c = 0)	//必须从右往左连续缺省，不能间隔
{
	cout << a << ' ' << b << ' ' << c << endl;
}
int main()
{
	Func(10); // 有几个未缺省，就必须传几个
	Func(10, 20); //传参是从左往右给（对于Func：先a 再b 然后c）
	Func(10, 20, 30);
}

Note：对于函数半缺省必须从右往左连续缺省，不能间隔。

Note：缺省参数不能在函数声明和定义中同时出现。

//test.h（头文件）
void Func ( int a = 10 );
// test.cpp
void Func ( int a = 20 )
{ }
// 如果声明与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那个缺省值。
// 声明与定义分离，那么缺省参数只能在声明中出现。 

  •      同时有缺省参数：

  (VS2019实现)  

  •       定义有缺省参数声明没有缺省参数：

 (VS2019实现)   

4、函数重载

        在C语言中是不允许同名函数的存在的。重载函数（overloaded function）是C++支持的一种特殊函数，C++编译器对函数重载的判断更是C++语言中极为复杂的内容之一。（一个函数有多个意义）

函数重载概念

         函数重载 （必须在同一个域里面才构成） ：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表 (参数个数、类型、类型顺序)必须不同 ，常用来处理实现功能类似数据类型不同的问题。

  • 参数列表的类型不同

#include<iostream>
using namespace std;
//参数列表的类型不同
int Add(int e1, int e2)
{
	return e1 + e2;
}
double Add(double e1, double e2)
{
	return e1 + e2;
}

  • 参数列表的类型顺序不同

#include<iostream>
using namespace std;
//参数列表的类型顺序不同
int Add(double e1, int e2)
{
	return e1 + e2;
}
double Add(int e1, double e2)
{
	return e1 + e2;
}

  • 参数列表的类型个数不同

#include<iostream>
using namespace std;
//参数列表的类型个数不同
int Add(int e1, int e2)
{
	return e1 + e2;
}
double Add(int e1, int e2, int e3)
{
	return e1 + e2;
}

Note：返回值不同不构成重载。（调用时无法进行区分）

5、引用（左值引用）

        引用(reference)为对象起了另外一个名字，声明类型引用(refers for)另外一种类型。通过将声明符写成 &变量名 的形式来定义引用类型。

Note：引用不是新定义一个对象，而是给已存在变量取了一个别名

类型& 引用变量名(对象名) = 引用实体；

int val = 1024;

int& refval = val; // refval指向val（是val的另一个名）

引用特性

int main()
{
        // 1、引用在定义是必须初始化
        int a = 10;

        // 2、一个变量可以有多个引用
        int& b = a;
        int& c = a;
        int& d = c;

        // 3、引用一旦引用一个实体，再不能引用其他实体
        int x = 20;
        b = x;  // b不是x的别名，而是将x赋值给b
        return 0;
}

使用场景

  • 做参数

//做参数 -- 1、输出型参数 2、大对象传参，提高效率
void Swap(int& e1, int& e2) 
{
    int tem = e1;
    e1 = e2;
    e2 = tem; 
}

  • 做返回值

// 返回返回对象的别名 -- 1、输出型返回对象，调用者可以修改返回对象 2、减少拷贝，提高效率
int& Count()
{
    static int n = 0；
    n++;

    // ...

    return n; 
}

常引用

        主要需要注意的是权限问题（权限的放大缩小只针对与引用与指针）。

int main()
{
	// 权限不能放大
	const int c = 20;
	int& d = c; // 错误

	// 权限可以缩小
	int e = 30;
	const int& f = e; // 正确

	int ii = 1;
	double& edd = ii; // 错误
	// 隐式转换会生成临时变量，而临时变量具有常属性，所以也是权限的放大。
}

引用和指针的区别

  • 在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间；指针开了4或8字节。
  • 在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

 (VS2019实现)   

引用和指针的不同点:

  1. 引用在定义时必须初始化，指针没有要求。
  2. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
  3. 没有NULL引用，但有NULL指针。
  4. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)。
  5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小。
  6. 有多级指针，但是没有多级引用。
  7. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理。
  8. 引用比指针使用起来相对更安全。（指针更强大，更危险，更复杂；引用相对局限一些，更安全，更简单）

6、内联函数

        以inline修饰的函数叫做内联函数

内联函数概念

        在编译中，时常会出现仅仅几行代码，却大量引用的问题，尤其是Swap交换函数。这导致多次的压栈与多次开辟栈帧，会出现大量的时间耗费。

//数据交换函数
void Swap(int e1, int e2)
{
    int tmp = e1;
    e1 = e2;
    e2 = tmp;
}

对此的优化：

       C语言对此提供了宏函数，但是由于宏：1，可读性差 2，没有类型安全检查 3，不方便调试。所以C++提出了内联函数，内联函数是一种以空间换时间的做法。

内联函数特性

        编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。如果定义为inline的函数体内有函数内部实现代码指令长度比较长或递归(会让编译出来的程序冗余)等等，编译器优化时会忽略掉内联。

//数据交换内联函数
inline void Swap(int e1, int e2)  //inline 符合条件的情况下，在调用的地方展开
{
    int tmp = e1;
    e1 = e2;
    e2 = tmp;
}

  • inline不建议声明和定义分离，分离会导致链接错误。

        因为inline被展开，就没有函数地址了，链接就会找不到。

// test.h
#include <iostream>
using namespace std ;
inline void fun ( int i );
-----------------------------------------------------
// test.cpp
#include "F.h"
void fun ( int number )
{
        cout << number   << endl ;
}
-----------------------------------------------------
// main.cpp
#include "F.h"
int main ()
{
        fun ( 10 );
        return 0 ;
}

 (VS2019实现)   

当程序开始运行：

  1. main.cpp：main运行，发现fun函数的调用，虽然，有对于其是内联函数的声明（test.h），但是没有内联函数的实现，所以只能call其地址。

  2. test.cpp：有对于其是内联函数的声明（test.h）,而内联函数不需要放入符号表（因为fun函数本身也不长，编译器会把inline函数就地展开，于是认为在调用的地方已经展开了）。

  3. 运行的时候：mian中的fun函数的调用想展开，但是没有函数的实现只有声明，所以只能选择call，然后，就导致连接不上。

所以，建议内联声明与定义不要分离。

7、auto关键字(C++11)

        编程时常常需要把表达式的值赋给变量，这就要求在声明变量的时候清楚地知道表达式的类型。然而这并非十分容易，在后面针对于复杂的类型，十分容易错误。而auto是让编译器去替我们去分析表达式所属的类型。

类型比较长的时候，auto自动推导：

#include <string>
#include <map>
int main ()
{
        std::map < std::string , std::string > m {{ "apple" , " 苹果 " },{ "orange" , " 橙子 "  }{ "pear" , " 梨 " }};
        std::map < std::string , std::string > :: iterator it = m . begin ();
        // auto it = m.begin();
        //....
        return 0 ;
} 
double fun()
{
	return 10.10;
}
int main()
{
	int a = 10;
	auto b = a;
	auto c = 'c';
	auto d = fun();
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;
	return 0;
}

 (VS2019实现)   

int main()
{
	int a = 10;
	auto b = &a;	//int
	auto* c = &a;	 //int*  *强调一定要传指针
	auto& d = a;	//int  &强调一定是引用
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;
	return 0;
}

  (VS2019实现)   

  • auto不能再同一行定义多个不同变量

        当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

void TestAuto ()
{
        auto a = 1 , b = 2 ;  // 可以
        auto c = 3 , d = 4.0 ;   // 该行代码会编译失败，因为 c 和 d 的初始化表达式类型不同
}

  • auto不能作为函数的参数

// 此处代码编译失败，程序执行的时候，需要对此函数生成指令，生成指令就要建立栈帧，参数是在这个栈帧里面的。然而，根本不知道它的类型，所以，不知道要开多大的栈帧。
void TestAuto ( auto a )
{ }

  • auto不能直接用来声明数组

//  数组的初始化是在运行期间完成的，而 auto 是在编译期间就完成 的 （先编译后运行）。 数组不能具有其中包含“ auto ” 的元素类型，即不能出现“ auto[] ”。
void TestAuto ()
{
        int a [] = { 1 ,  2 ,  3 };
        auto b [] = { 4,  5,  6 };
}

8、基于范围的for循环(C++11)

        C++11新标准引入一种更简单的 for 语句，这种语句可以遍历容器或其他序列的所有元素。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

void Test_For()
{
    int array[] = { 1, 2, 3, 4, 5 };

    for (auto e : array)    //变化前
        cout << e << " ";
    cout << endl;

    for (auto& e : array)   //使用应用使得可以更改数据
        e *= 2;

    for (auto e : array)    //变化后
        cout << e << " ";
    cout << endl;
}

         范围for自动推导类型，自动取array中的值赋值给e，自动迭代（自动++），自动的判断结束。

 (VS2019实现)  

Note：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。

9、指针空值---nullptr(C++11)

        在之前的C++98中的指针空值中，我们所使用的空指针的定义是NULL。

         所以，相对应的以宏将NULL定义为0，就会出现一下类似的情况等：

using namespace std;
void pointer(int)
{
	cout << "pointer(int)" << endl;
}

void pointer(int*)
{
	cout << "pointer(int*)" << endl;
}

int main()
{
	int* p = NULL;
	pointer(0);
	pointer(NULL);
	pointer(p);
	return 0;
}

 (VS2019实现)  

        pointer(NULL)传递的是int类型的。

#include <iostream>
using namespace std;
void pointer(int)
{
	cout << "pointer(int)" << endl;
}

void pointer(int*)
{
	cout << "pointer(int*)" << endl;
}

int main()
{
	pointer(nullptr);
	return 0;
}

 (VS2019实现)  

        pointer(nullptr)传递的是int*类型的。

Note：

  1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
  2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。 (可以理解为nullptr在底层就等价于0。然后，强转成了(void*)0)
川入
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++中auto关键字的使用
qq_56416885的博客
11-08 2125
简述C++中auto关键字的使用
C++入门（2）--引用，内联，auto
weixin_73602892的博客
02-20 140
对C++初步的简单的认识
【C++初阶】C++入门二（引用、内联函数、auto、范围for、nullptr等）
codewinter的博客
10-15 475
文章目录（1）引用（很重要）1）引用的概念2）引用的特性3）常引用4）引用的使用场景1、做函数参数2、做函数返回值（要非常的谨慎）5）传值&传引用的效率比较6）值返回&引用返回的性能比较（2）引用和指针的区别（3）内联函数1）内联函数的概念2）内联函数的特性下面的内容仅是为了提前了解一下，让我们对C++有一个整体的概念：（4）auto关键字（C++11）1）auto简介2）auto的使用规则3）auto不能推导的场景（5）基于范围的for循环（C++11）1）范围for的语法2）范围for的
【C++学习】C++入门 | 引用 | 引用的底层原理 | auto关键字 | 范围for（语法糖）
Locky136的博客
06-24 539
C++入门 | 引用 | 引用的底层原理 | auto关键字 | 范围for（语法糖）
「C++学习笔记」引用、内联函数、auto、范围for、nullptr
zheshuiyu的博客
03-08 103
本文简要介绍了： 引用的概念、引用的一些细节、常引用、引用作为函数参数、引用作为函数返回值、引用作为函数参数时的效率、引用作为函数返回值时的效率、引用与指针的区别 内联函数的使用、内联函数的一些细节 auto的使用、auto的一些细节 范围for的使用 nullptr的由来
【C++---START】入门（上）
Austin_Yan的博客
06-03 4616
文章目录C++关键字:命名空间:C++输入与输出:缺省参数:全缺省参数:半缺省参数:函数重载: C++关键字: C++98中总共有63个关键字 命名空间: 命名空间的定义需要使用namespace关键字,后面跟空间的名字,成员包含在{}中,与结构体不同的是末尾不需要; 命名空间定义: 命名空间嵌套: 命名空间使用: 输出: C++输入与输出: 使用cout标准输出(控制台)和cin...
C++入门基础(万字总结）（建议收藏！！！）
热门推荐
IamGreeHand的博客
09-22 25万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
C++ -9 入门视频教程
03-15
"C++ -9 入门视频教程"可能涵盖的内容丰富多样，旨在帮助初学者建立起对C++语言的基本理解和应用能力。 1. **C++基础语法**：C++的基础包括变量、数据类型、运算符、流程控制（如if条件语句、switch语句、for循环、...
C++入门教程视频-1
03-05
"C++入门教程视频-1"是一个适合初学者的教育资源，旨在帮助新手理解并掌握C++的基础概念。这个教程可能包含了以下几个核心知识点： 1. **数据类型**：在C++中，数据类型是用于定义变量存储不同类型数据的类别。在...
c++入门-中级学习大纲
08-15
c++入门学习大纲、对应市场上中级开发
C++初阶 - 入门.pdf
01-15
C++初阶 - 入门.pdf C++是一种功能强大且灵活的编程语言，它是由Bjarne Stroustrup在1983年开发的。C++是C语言的超集，添加了对象导向编程的特性，使得编程更加灵活和高效。 1. C++98标准 C++98是C++语言的第一个...
C++入门-初识类与对象
10-22
思维导图
C++入门（三）引用，内联，auto+nullptr
weixin_53316121的博客
05-12 721
一、引用 定义 引用是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。 与之前学过的取地址共用符号：& 在类型前加& 举例 特性 1. 引用在定义时必须初始化 2. 一个变量可以有多个引用 如举例所示 3. 引用一旦引用一个实体，再不能引用其他实体 常引用 在变量前 或 引用前加 const ,使其变成常量后加引用或变成常引用 取别名原则 对原引用的变量，权限只能缩小或...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1131
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++二叉搜索树
Jk_Mr的博客
07-20 1129
树结构是一种重要的数据结构。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
C++笔试强训7
m0_74189279的博客
07-21 972
这意味着编译器会尝试将函数的代码直接插入到每个调用该函数的地方，而不是像通常那样进行函数调用（即，生成调用指令，跳转到函数代码，执行函数体，然后返回）。友元函数是在类外部定义的普通函数，它只能通过传入的参数（如果有的话）来访问类的成员，或者通过类的对象显式地访问（如果该函数设计为接受类的对象作为参数）。函数参数默认值又叫缺省参数，缺省参数必须从右向左开始缺省，必须连续给定缺省值，也就是说，从左到右，一旦遇到一个参数是缺省的，那么之后的参数也必须都是缺省的。指针是类成员函数特有的，用于指向调用该函数的对象。
商品信息管理系统(C语言)
最新发布
zeyeqianli的博客
07-22 325
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
C++笔记3：基类指针delete子类对象的内存泄漏问题
subtitle_的博客
07-21 260
C++笔记3：基类指针delete子类对象的内存泄漏问题
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
面试高手的博客
07-21 4万+
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]
C++编程入门指南 - 从基础到面向对象
"C++ 基础教程 - v1.3" C++ 是一种由Bjarne Stroustrup在1979年创立的编程语言，最初作为C语言的增强版，起初名为"C with Classes"，后在1983年正式命名为C++。它是一种静态类型、编译式的、通用的、大小写敏感、不...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

川入

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值