C++入门基础1

RRYc666

于 2024-09-15 15:43:56 发布

阅读量353

点赞数 13

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/Rosillll/article/details/140891827

版权

一.C++的第一个程序

C++兼容C语言绝大部分的语法，所以C语言实现的hello world在C++中依旧可以运行，C++中需要把源文件后缀改为.cpp，VS编译器看到.cpp就会调用C++编译器进行编译，Linux下用的是g++编译，而不再是gcc编译器。

//test.cpp
#include<stdio.h>
int main()
{
printf("Hello World\n");
return 0;
}

当然C++有一套自己的输入输出，严格说C++版本的hello world应该是这样写的。

#include<iostream>
using namespace std;
int main()
{
cout << "Hello world" << endl; //endline：换行符
return 0;
}

二.namespace（命名空间）

1.namespace的介绍

在c/c++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称都存在于全局变量中，可能会导致很多冲突。使用命名变量的空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

c语言项目类似下面这样的命名冲突是普遍存在的问题，c++引入namespcae就是为了更好地解决这样的问题。

#include<stdio.h>
#include<stdlib.h>

//域
namespace ryc
{
   int rand = 10;//注意：全局变量
}

int a = 0;

int main()
{
   printf("%p\n", rand); //默认访问全局，rand为函数名（地址），用%p打印
   printf("%d\n", ryc::rand);//访问域作用下的整形变量rand

   int a = 1;
   printf("%d\n", a); //局部优先，默认访问局部变量a
   printf("%d\n", ::a);//::左边什么都没有，默认访问全局变量a，::表示域作用限定符

   return 0;
}

2.namespace的定义

1、定义命名空间，需要使用到namespace关键字，后面跟跟命名空间的名字，然后接一对{}即可。{}中即为命名空间的成员。命名空间中可以定义变量、函数、类型等。

2、namespace本质是定义一个域，这个域跟全局域各自独立，不同的域可以定义同名变量，所以与上面的rand并不冲突。

3、c++中域有：函数局部域、全局域、命名空间域、类域；域影响的是编译时语法查找一个变量函数类型的出处。有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不影响变量生命周期。访问时候需要加上 : : 域作用限定符。

#include<stdio.h>
namespace ryc
{
   int rand = 10;
   int Add(int a, int b)
   {
       return a + b;
   }
   struct Node
   {
       struct Node* next;
       int val;
   };
}
int main()
{
   //printf("%d\n", Add(1, 2));默认到局部/全局找Add函数，找不到error
   printf("%d\n", ryc::Add(1, 2));//指定域，才能找到Add函数

   //struct Node p1;同理error
   //ryc::struct Node p1;error，注意：ryc::的位置
   struct ryc::Node p1;//当然struct可以省略

   return 0;
}

4、namespace 只能定义在全局，也可以嵌套定义。

5、项目工程中多文件中定义的同名namespace会认为是同一个namespace，不会冲突。

#include<stdio.h>
//命名空间可以嵌套
namespace ryc
{
   namespace A
   {
       int rand = 10;
   }
   namespace B
   {
       int rand = 20;
   }
}
int main()
{
   printf("%d\n", ryc::A::rand);
   printf("%d\n", ryc::B::rand);

   return 0;
}

6、c++标准库都放在一个叫std(standard)的命名空间中。

3.namespace的使用

编译查找一个变量的声明/定义时，默认只会在局部或者全局查找，不会到命名空间里面去查找，若局部或者全局没有则编译错误。所以我们要使用命名空间中定义的变量/函数。

namespace ryc
{
   int a = 1;
   int b = 2;
}
using namespace ryc;//展开ryc命名空间中全部成员。

int main()
{
   printf("%d\n", a);
   printf("%d\n", b);
   return 0;
}

三、C++的输入与输出

1、<iostream>是input 和 output Stream的缩写，是标准的输入、输出流库，定义了标准的输入、输出对象。

2、std::cin是istream类的对象，它主要面向窄字符的标准输入流。

3、std::cout是ostream类的对象，它主要面向窄字符的标准输出流。

4、std::endl是一个函数，流输入输出时，相当于插入一个换行字符加刷新缓冲区。

5、<<是流插入运算符，>>是流提取运算符。（C语言中：移位运算左移/右移）。

6、使用C++输⼊输出更方便，不需要像printf/scanf输入输出时那样，需要手动指定格式，C++的输入输出可以自动识别变量类型(本质是通过函数重载实现的)，其实最重要的是C++的流能更好的⽀持自定义类型对象的输⼊输出。

7、IO流涉及类和对象，运算符重载、继承等很多面向对象的知识。

8、cout/cin/endl等都属于C++标准库，C++标准库都放在⼀个叫std(standard)的命名空间中，所以要通过命名空间的使用方式去用他们。

9、一般日常练习中我们可以using namespace std，实际项目开发中不建议using namespace std。

10、这里我们没有包含<stdio.h>，也可以使用printf和scanf，在包含<iostream>间接包含了。vs系列编译器是这样的，其他编译器可能会报错。

四.缺省参数（函数的默认参数）

1、缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参数则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。（有些地方把缺省参数也叫默认参数）

2、全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。

3、带缺省参数的函数调用，C++规定必须从左到右依次给实参，不能跳跃给实参。

4、函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。否则不知道调用函数的声明还是函数的定义。

#include<iostream>
using namespace std;

//全缺省
void Func1(int a = 10,int b = 20, int c = 30)
{
   cout << "a = " << a << endl;
   cout << "b = " << b << endl;
   cout << "c = " << c << endl;
}

//半缺省
void Func2(int a , int b = 20, int c = 30)
{
   cout << "a = " << a << endl;
   cout << "b = " << b << endl;
   cout << "c = " << c << endl;
}

int main()
{
   Func1();
   Func1(1);
   Func1(1,2);
   Func1(1,2,3);


   //错误 Func2();
   Func2(100);
   Func2(100,200);
   Func2(100,200,300);

   return 0;
}

五.函数重载

C++支持在同一作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同、参数类型不同、参数类型顺序不同 。返回值不同不能作为重载条件，因为调用时也无法区分。这样C++函数调用就表现出了多态行为，使用更灵活。C语言是不支持同一作用域中出现同名函数。

#include<iostream>
using namespace std;

// 1、参数类型不同
int Add(int left, int right)
{
   cout << "int Add(int left, int right)" << endl;
   return left + right;
}
double Add(double left, double right)
{
   cout << "double Add(double left, double right)" << endl;
   return left + right;
}

// 2、参数个数不同
void f()
{
   cout << "f()" << endl;
}
void f(int a)
{
   cout << "f(int a)" << endl;
}

// 3、参数类型顺序不同
void f(int a, char b)
{
   cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
   cout << "f(char b, int a)" << endl;
}
int main()
{
   Add(10, 20);
   Add(10.1, 20.2);

   f();
   f(10);

   f(10, 'a');
   f('a', 10);

   return 0;
}

注意：返回值不同不能作为重载条件，因为调用时也无法区分

六.引用

1.引用的概念和定义

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。比如：水浒传中的林冲，外号是豹子头。

语法：类型& 引用别名 = 引用对象;

#include<iostream>
using namespace std;

int main()
{
   int a = 0;

   // 引用：b和c是a的别名
   int& b = a;
   int& c = a;

   // 也可以给别名b取别名，d相当于还是a的别名
   int& d = b;
   ++d;

   // 这里取地址我们看到是一样的
   cout << &a << endl;
   cout << &b << endl;
   cout << &c << endl;
   cout << &d << endl;

   return 0;
}

2.引用的特性

1、引用在定义时必须初始化。

2、一个变量可以有多个引用。

3、引用一旦引用一个实体，再不能引用其他实体。

3.引用的使用

1、引用在实践中主要是用于 引用传参 和 引用做返回值 中减少拷贝提高效率和改变引用对象时同时改变被引用对象。

2、引用传参跟指针传参功能是类似的，引用传参相对方便一点。

3、不能返回局部变量的引用，否则造成野指针，可以返回堆区的引用。

4、引用和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。C++的引用跟其他语⾔的引用(如Java)是有很大的区别的，除了用法，最大的点，C++引用定义后不能改变指向，Java的引用可以改变指向。

5、一些主要用C代码实现版本数据结构教材中，使用C++引用替代指针传参，目的是简化程序，避开复杂的指针。

void swap(int& x, int& y)
{
   int tmp = x;
   x = y;
   y = tmp;
}

int main()
{
   int a = 10;
   int b = 20;
   cout << "a =" << a << endl;
   cout << "b =" << b << endl;

   swap(a, b);

   cout << "a = " << a << endl;
   cout << "b = " << b << endl;

   return 0;
}

4、const指针

1、可以引用一个const对象，但是必须用const引用。const引用也可以引用普通对象，因为对象的访问权限在引用过程中可以缩小，但是不能放大。

#include<iostream>
using namespace std;

int main()
{
   const int a = 10;//只能读，不能修改
   //编译报错：error C2440：“初始化”：无法从“const int”转化为“int &”
   //这里的引用是对a访问权限的放大
   //int& ra = a;可以读，可以修改，放大了权限

   //这样才可以
   const int& ra = a;
   //ra++;error

   //权限可以缩小，但是不能放大
   int b = 20;
   const int& rb = b;
   b++;//right，b的权限没有发生改变
   //rb++;error

   //int& rc = 30;error，30是常量，引用将其权限放大了
   const int& rc = 30;//right

   //int& rc = (a + b);error，a+b的值存放在了一个临时对象，具有常量的性质，权限放大
   const int& rc = (a + b);//right

   return 0;
}

2、需要注意的是类似 int& rb = a+b; double d = 12.34; int& rd = d; 这样一些场景下 a+b的和结果保存在一个临时对象中， int& rd = d 也是类似，在类型转换中会产生临时对象存储中间值，也就是时，rb和rd引用的都是临时对象，而C++规定临时对象具有常性，所以这里就触发了权限放大，必须要用常引用才可以。

3、所谓临时对象就是编译器需要一个空间暂存表达式的求值结果时临时创建的一个未命名的对象，C++中把这个未命名对象叫做临时对象。

5、指针与引用的关系

C++中指针和引用就像两个性格迥异的亲兄弟，指针是哥哥，引用是弟弟，在实践中他们相辅相成，功能有重叠性，但是各有自己的特点，互相不可替代。

1、语法概念上引用是一个变量的取别名不开空间，指针是存储一个变量地址，要开空间。

2、引用在定义时必须初始化，指针建议初始化，但是语法上不是必须的。

3、引用在初始化时引用一个对象后，就不能再引用其他对象；而指针可以在不断地改变指向对象。

4、引用可以直接访问指向对象，指针需要解引用才是访问指向对象。

5、sizeof中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节个数（32位平台下占4byte，64位下是8byte）。

6、指针很容易出现空指针和野指针的问题，引用很少出现，引用使用起来相对更安全一些。

七、inline（内联）

1、用inline修饰的函数叫做内联函数，编译时C++编译器会在调用的地方展开内联函数，这样调用内联函数就不需要建立栈帧了，就可以提高效率。

2、inline对于编译器而言只是一个建议，也就是说，你加了inline编译器也可以选择在调用的地方不展开，不同编译器关于inline什么情况展开各不相同，因为C++标准没有规定这个。inline适用于频繁调用的短小函数，对于递归函数，代码相对多一些的函数，加上inline也会被编译器忽略。

3、C语言实现宏函数也会在预处理时替换展开，但是宏函数实现很复杂很容易出错的，且不方便调试，C++设计了inline目的就是替代C的宏函数。

#include<iostream>
using namespace std;

//实现一个ADD宏函数的常见问题
//#define ADD(int a, int b) return a + b;
//#define ADD(a, b) a + b;
//#define ADD(a, b) (a + b)

//正确的宏实现
#define ADD(a, b) ((a) + (b))

int main()
{
   int ret = ADD(1, 2);//int ret = ((1)+(2));

   //1.为什么不能加分号?
   cout << ADD(1, 2) << endl; //cout << ADD(1, 2); << endl;error

   //2.为什么要加外面的括号?
   cout << ADD(1, 2) * 5 << endl; //1 + 2 * 5，*优先级高于+

   //3.为什么要加里面的括号?
   int x = 1, y = 2;
   ADD(x & y, x | y); // -> (x&y+x|y) +优先级高于位运算符

   return 0;
}