C++基础语法（一）

C++简介

C++ 是一种静态类型的、编译式的、通用的、大小写敏感的、不规则的编程语言，支持过程化编程、面向对象编程和泛型编程。

C++是一种中级语言，综合高级语言和低级语言的特点，它是C的超集。

使用静态类型的编程语言是在编译时执行类型检查，而不是在运行时执行类型检查。

C++ 完全支持面向对象的程序设计，包括面向对象开发的四大特性：

封装
数据隐藏
继承
多态

其中C++由三个重要部分组成：

核心语言，提供了所有构件块，包括变量、数据类型和常量，等等。
C++ 标准库，提供了大量的函数，用于操作文件、字符串等。
标准模板库（STL），提供了大量的方法，用于操作数据结构等。

基本语法

C++ 程序可以定义为对象的集合，这些对象通过调用彼此的方法进行交互。

对象 - 对象具有状态和行为。
类 - 类可以定义为描述对象行为、状态的模板。
方法 - 从基本上说，一个方法表示一种行为。
即时变量 - 每个对象都有其独特的即时变量。

开发环境

这里推荐使用工具Clion进行开发，下载并安装Clion，然后创建项目运行即可。

如果是一个工程中包含多个源文件，每个源文件都有单独的main()方法，需要进行单独编译，此时可以下载插件：File - Setting -> Plugins -> C/C++ Single File Execution。

编写源代码文件后，右键面板中选择：Add excutable for single c/c++ file，此时会在CMarksLists.txt中自动生成如下代码：

add_executable(xxx xxx.cpp)

在运行的时候注意手动切换运行的源文件即可。

基本结构

我们来看C++的入门程序的结构：

#include <iostream>	// 定义头文件
int main() { // 入口函数
    std::cout << "Hello, World!" << std::endl;	// 输出操作
}

std:是命名空间，可以使用using namespace std;来使用std命名空间。

#include <iostream>
using namespace std;
int main() {
    cout << "Hello, World!" << endl;
}

编译和执行有两种方式：通过g++ xxx.cpp指令编译或者通过makefile来编译C++程序。

C++所有的语句都是以分号作为结束符，它表明一行语句的结束。

其中，C++的标志符命名主要有如下规则：

以字母 A-Z 或 a-z 或下划线 _ 开始，后跟零个或多个字母、下划线和数字（0-9）
标识符内不允许出现标点字符，比如 @、$ 和 %
标志符命名的大小写敏感，也就是区分大小写

C++中还有很多保留字，这些保留字不能作为常量、变量或其他标志符名称。

C++还包括三字符序列的方式用来表示特殊字符（不推荐使用）：

在C++中的注释包含单行注释和多行注释：

// 这是单行注释
/* 这是多行注释，可以跨行 */

数据类型

基本类型

C++中内置丰富的数据类型和自定义的数据类型，如下表所示：

一些基本类型可以使用一个或多个类型修饰符进行修饰：

signed
unsigned
short
long

下表列出各种类型变量在内存中所占的字节数和取值范围：

注意：不同的编译器和不同的电脑也会有所不同，也就是不同系统会有所差异。

下面编写实例来输出电脑上各种数据类型的大小：

#include <iostream>
using namespace std;
int main() {
    cout << "char：" << sizeof(char) << endl;
    cout << "int：" << sizeof(int) << endl;
    cout << "short int：" << sizeof(short int) << endl;
    cout << "long int：" << sizeof(long int) << endl;
    cout << "float：" << sizeof(float) << endl;
    cout << "double：" << sizeof(double) << endl;
    cout << "wchar_t：" << sizeof(wchar_t) << endl;
    return 0;
}

使用 sizeof() 函数来获取各种数据类型的大小。使用endl来进行换行操作。输出的结果如下：

char：1
int：4
short int：2
long int：4
float：4
double：8
wchar_t：2

typedef声明

使用typedef为已知的类型取一个别名，具体的语法如下：

typedef type name;

假设，下面的语句告诉编译器，feet是int类型的别名，声明方式如下:

typedef int feet;

那么，可以通过feet来声明int类型的整形变量：

feet var1,var2,var3;

枚举类型

C++中，枚举类型的创建方式需要使用关键字enum来声明，具体语法如下：

enum enum-name { list of names } var-list

默认情况下，索引都是从0开始以此类推。

示例代码如下所示：

enum color { red, green, blue, white } c;
c = blue;

如果想自定义枚举的值，只需要添加一个初始值即可：

enum color { red, green=5, blue, white };

由于green为5，在默认情况下，后续的名称都会比它名称大1。也就是blue是6，white是7。

变量

变量定义

C++中变量的定义使用如下语法：

type variable_list;

示例代码如下所示：

int i, j, k;
char c, ch;
float f, salary;
double d;

除此之外，还可以在初始化的时候给变量赋予初始值：

extern int d = 3, f = 5;
int d = 3, f = 5;
byte b = 22;
char c = ‘c‘;

如果没有赋予初始值的情况下，默认为null或0。

其中extern关键字是变量的声明，虽然可以在 C++ 程序中多次声明一个变量，但变量只能在某个文件、函数或代码块中被定义一次。

#include <iostream>
using namespace std;

// 变量声明
extern int a, b;
extern int c;
extern float  f;

int main() {
  // 变量定义
  int a, b;
  int c;
  float f;

  // 实际初始化
  a = 10;
  b = 20;
  c = a + b;
  cout << c << endl;

  f = 70.0/ 3.0;
  cout << f << endl;
}

执行的输出结果如下：

30
23.3333

同样的，在函数声明时，提供一个函数名，而函数的实际定义则可以在任何地方进行。例如：

// 函数声明
int func();
int main(){
  // 函数使用
  int i = func();
}

// 函数定义
int func(){
  return 0;
}

左值（Lvalues）和右值（Rvalues）

C++ 中有两种类型的表达式：

左值（lvalue）：指向内存位置的表达式被称为左值（lvalue）表达式。左值可以出现在赋值号的左边或右边。
右值（rvalue）：术语右值（rvalue）指的是存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式，也就是说，右值可以出现在赋值号的右边，但不能出现在赋值号的左边。

一般变量是左值，因此可以出现在赋值号的左边。数值型的字面值是右值，因此不能被赋值，不能出现在赋值号的左边。下面是一个有效的语句“

int a = 20;

变量作用域

作用域是程序的一个区域，一般来说有三个地方可以声明变量：

在函数或一个代码块内部声明的变量，称为局部变量。
在函数参数的定义中声明的变量，称为形式参数。
在所有函数外部声明的变量，称为全局变量。

局部变量

在函数或一个代码块内部声明的变量，称为局部变量。它们只能被函数内部或者代码块内部的语句使用。

#include<iostream>
using namespace std;

int main(){
  // 局部变量
  int a, b;
  int c;

  // 初始化变量
  a = 10;
  b = 20;
  c = a+ b;
  cout << c;
  return 0;
}

全局变量

在函数外部定义的变量，称为全局变量，在整个程序生命周期内有效。

#include <iostream>
using namespace std;
// 全局变量
int g;
int main(){
  // 局部变量
  int a, b;
  // 初始化
  a = 10;
  b = 20;
  g = a+ b;
  cout << g;
  return 0;
}

注意：当局部变量和成员变量相同时，局部变量会覆盖全局变量的值。

#include <iostream>
using namespace std;
int g = 20; // 全局变量
int main(){
  int g = 10; // 局部变量
  cout << g;
  return 0;
}

输出结果如下：

10

常量

常量是固定值，在程序执行期间不会改变。这些固定的值，又叫做字面量。
我们常见的常量包含如下：

整数常量
浮点常量
布尔常量
字符常量
字符串常量

常量的定义有两种方式：#define预处理器和const关键字

#define预处理器

使用#define预处理器来定义的方式如下：

#define indentifier value

一般常量使用方式如下：

#include <iostream>
using namespace std;
#define LENGTH 10
#define WIDTH  5
#define NEWLINE ‘\n‘

int main(){
  int area;
  area = LENGTH * WIDTH;
  cout << area;
  cout << NEWLINE;
  return 0;
}

const关键字

可以使用const 前缀声明指定类型的常量，如下所示：

const type variable = value;

实例如下所示：

#include <iostream>
using namespace std;

int main() {
   const int  LENGTH = 10;
   const int  WIDTH  = 5;
   const char NEWLINE = ‘\n‘;
   int area;  
   
   area = LENGTH * WIDTH;
   cout << area;
   cout << NEWLINE;
   return 0;
} 

注意：在程序开发中，常量一般都使用大写的方式表示。

修饰符

C++允许在char、int和double数据类型前放置修饰符。修饰符用于改变基本类型的含义

下面列出了数据类型修饰符：

signed
unsigned
long
short

修饰符 signed、unsigned、long 和 short 可应用于整型，signed 和 unsigned 可应用于字符型，long 可应用于双精度型。

C++ 允许使用速记符号来声明无符号短整数或无符号长整数。您可以不写 int，只写单词 unsigned short 或 unsigned long，int 是隐含的。

unsigned x;
unsigned int y;

下面实例演示有符号整数和无符号整数修饰符之间的差别：

#include <iostream>
using namespace std;
int main(){
  short int i;  // 有符号短整数
  short unsigned int j; // 无符号短整数
  j = 50000;
  i = j;
  cout << i << "|" << j;
  return 0;
}

输出结果如下：

-15536|50000

上述结果中，无符号短整数 50,000 的位模式被解释为有符号短整数 -15,536。

类型限定符

类型限定符提供了变量的额外信息。

存储类

存储类定义 C++ 程序中变量/函数的范围（可见性）和生命周期。

auto
register
static
extern
mutable

auto存储类

auto 存储类是所有局部变量默认的存储类。

{
   int mount;
   auto int month;
}

上面的实例定义了两个带有相同存储类的变量，auto 只能用在函数内，即 auto 只能修饰局部变量。

register存储类

register 存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。

所以它的最大尺寸等于寄存器大小，且不能对它应用一元的‘&‘运算符（没有内存位置）。

{
   register int  miles;
}

寄存器只用于需要快速访问的变量，比如计数器。（可能存储在寄存器，取决硬件限制）

static存储类

static修饰局部变量时，会让局部变量在函数之间调用而不会被销毁。

static修饰全局变量时，会使变量的作用域限制在声明它的文件内。

#include <iostream>
using namespace std;
void func(void);  // 函数声明
static int count = 10;  // 全局变量
int main(){
  while (count--){
    func();
  }
  return 0;
}

// 函数定义
void func(void){
  static int i = 5; // 局部静态变量
  i++;
  cout << "i = " << i;
  cout << "，count = " << count << endl;
}

当上面的代码被编译和执行时，它会产生下列结果：

i = 6，count = 9
i = 7，count = 8
i = 8，count = 7
i = 9，count = 6
i = 10，count = 5
i = 11，count = 4
i = 12，count = 3
i = 13，count = 2
i = 14，count = 1
i = 15，count = 0

由于局部变量i使用static修饰，所以它的值每次都是累加的，如果不用static修饰则一直是6。

extern存储类

extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。

extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候，如下所示：

第一个文件

#include <iostream>
int count;
extern void writeExtern();
int main(){
  count  = 5;
  writeExtern();
}

第二个文件

#include <iostream>
using namespace std;
extern int count;
void writeExtern(void){
  cout << "count is:" << count << endl;
}

第二个文件使用extern声明已经存在第一个文件定义的count。输出结果如下：

count is:5

mutable存储类

mutable 说明符仅适用于类的对象，它允许对象的成员替代常量。也就是说，mutable 成员可以通过 const 成员函数修改。

运算符

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。

算术运算符
关系运算符
逻辑运算符
位运算符
赋值运算符
其他运算符

算数运算符

下表显示了 C++ 支持的算术运算符。

关系运算符

下表显示了 C++ 支持的关系运算符。

逻辑运算符

下表显示了 C++ 支持的逻辑运算符。

位运算符

位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：

假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示：

A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011

下表显示了 C++ 支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则：

赋值运算符

下表列出了 C++ 支持的赋值运算符：

其他运算符

下表列出了 C++ 支持的其他一些重要的运算符。

01、C++--基础语法（一）

原文：https://www.cnblogs.com/pengjingya/p/14391621.html