基础语法 (opens new window)

hello world

#include <iostream>
//告诉编译器使用 std 命名空间,可简化代码:  std::cout -> cout
using namespace std;

// main() 是程序开始执行的地方
int main(){

    // 输出 Hello World
    // std::endl 这将在每一行后插入一个换行符,等同于 \n
    std::cout << "Hello World" << std::endl;
    cout << "等效与上一行代码\n";

   return 0;
}

基本的内置类型

类型	关键字
布尔型	bool
字符型	char
整型	int
浮点型	float
双浮点型	double
无类型	void
宽字符型	wchar_t （typedef short int wchar_t;）

typedef 声明

您可以使用 typedef 为一个已有的类型取一个新的名字。下面是使用 typedef 定义一个新类型的语法： typedef type newname;

#include <iostream>

typedef int feet;

int main() {
    feet a = 1;
    std::cout << a ;
}

枚举类型

#include <iostream>

int main(){
    //默认情况下，枚举第一个名称的值为 0，第二个名称的值为 1，第三个名称的值为 2
    enum color { red, green, blue } c;

    c = blue;
    //输出2
    std::cout << "当前颜色："<<(c) << std::endl;

    enum color2 { white, black=3, pink } b;
    b= pink;
    //在这里 pink 的值为 4，因为默认情况下，每个名称都会比它前面一个名称大 1，但 white 的值依然为 0。
    std::cout << "white:"<<(b) << std::endl;
    b= white;
    std::cout << "blue:"<<(b) <<std::endl;
    return 0;
}

定义和声明

声明

• 作用：告诉编译器某个实体（变量、函数、类等）的存在及其类型/签名。
• 不分配内存，仅引入标识符的约定（如 extern int x;）。
• 可多次重复（同一作用域内）。

定义

• 作用：为实体分配具体内存（变量）或提供完整实现（函数/类）。
• 是声明的具体实例化（如 int x = 5; 或函数体 {}）。
• 同一作用域内只能存在一个（ODR 规则）。

变量：extern int a;（声明） vs int a = 10;（定义）。

函数：void func();（声明） vs void func() { ... }（定义）。

类：class MyClass;（前向声明） vs class MyClass { ... };（完整定义）。

#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 ;

  return 0;
}

全局变量和局部变量

#include <iostream>
using namespace std;

//所有函数外部定义的变量（通常是在程序的头部），称为全局变量。全局变量的值在程序的整个生命周期内都是有效的。
//全局变量可以被任何函数访问。也就是说，全局变量一旦声明，在整个程序中都是可用的
int global=2;
int b=3;

void run(){
    cout << global << endl ;
}

int main (){

  cout << global << endl ;
  //在函数或一个代码块内部声明的变量，称为局部变量。它们只能被函数内部或者代码块内部的语句使用
  int a =1;
  cout << a << endl ;
  cout << b << endl ;// 打印3
  //局部变量和全局变量的名称可以相同，但是在函数内，局部变量的值会覆盖全局变量的值
  int b =4;
  cout << b << endl ; //被覆盖打印2

  //调用另一个函数
  run();

  return 0;
}

常量

常量是固定值，在程序执行期间不会改变。这些固定的值，又叫做字面量。

常量可以是任何的基本数据类型，可分为整型数字、浮点数字、字符、字符串和布尔值。

常量就像是常规的变量，只不过常量的值在定义后不能进行修改。

定义常量

#include <iostream>
using namespace std;

//  const 定义常量
const char  A = 'A';
// #define 定义常量
#define  MAX 999

int main (){
  #define  MIN 0
  const char  B = 'B';
  cout << A << endl ;
  cout << B << endl ;
  cout << MAX << endl ;
  cout << MIN << endl ;
  return 0;
}

修饰符

有符号整数和无符号整数之间的差别

#include <iostream>
using namespace std;

int main()
{
   short int i;           // 有符号短整数
   short unsigned int j;  // 无符号短整数

   //unsigned short int  无符号短整型2个字节16位，最大值 : 1111 1111 1111 1111
   //61400 ->1110 1111 1101 1000
   //赋值无符号不会超出正常显示
   j = 61400;

   //  short int 有符号短整型
   // 61400
   //1 110 1111 1101 1000
   //最高位为1 负数，计算补码,计算规则：保留符号位，原码取反+1
   //1 001 0000 0010 0111
   //1 001 0000 0010 1000 ->其中  001 0000 0010 1000 == 4136 ,高位为1为负数
   //1 001 0000 0010 1000 > -4136
   i = j;
   cout << i << " " << j;

   return 0;
}

存储类

存储类定义 C++ 程序中变量/函数的范围（可见性）和生命周期。这些说明符放置在它们所修饰的类型之前。下面列出 C++ 程序中可用的存储类：

• auto
• register
• static
• extern
• mutable
• thread_local (C++11)

。。。。

函数

C++ 中函数可以给默认值

#include <iostream>

int sum(int a, int b=20) { // 默认参数仅在 C++ 中有效
    return a + b;
}
/*
 * 这个程序演示了有符号整数和无符号整数之间的差别
*/
int main()
{
    // 等效于 sum(10, 20)
    std::cout << sum(10) << std::endl; //30
    // 显式传两个参数
    std::cout << sum(2,7) << std::endl; //9
   return 0;
}

lambda

特性	说明
[=]	值捕获（只读）
[&]	引用捕获（可以修改原变量）
[x, &y]	混合捕获（部分值/部分引用）
[this]	捕获类成员（用于类方法内）
[=, &x]	默认值捕获 + 特殊引用捕获

#include <iostream>

void reset(int* a,int* b,int* c){
     *a  = 1;
     *b = 2;
     *c = 2;
}

int main(){
    int a  = 1;
    int b = 2;
    int c = 2;
    //值捕获 [=]（副本，不可修改）
    auto fun = [=](){
        // a=3;  //= 捕获不允许修改编译报错
        return a+b+c;
    };
    std::cout <<"fun:"<< fun() << std::endl;
    //重置值
    reset(&a,&b,&c);

    //引用捕获 [&]（可修改原变量）
    auto fun2 = [&](){
        a=10;
        b=20;
        c=30;
        return a+b;
    };
    std::cout << "fun2:" << fun2() << std::endl;
    //重置值
    reset(&a,&b,&c);

    //混合捕获  [a,b,&c]
    auto fun3 = [a,b,&c](){
        // a=3;  //a 不是引用不允许修改
        // b=3;  //b 不是引用不允许修改
        c=30; //&c 可以修改
        return a+b+c;
    };
    std::cout << "fun3:" << fun3() << std::endl;
    //重置值
    reset(&a,&b,&c);

    //混合捕获  [a,b,&c]
    auto fun4 = [=,&a](){
        //&a 是引用可以修改
        a=40;
        return a+b+c;
    };
    std::cout << "fun4:" << fun4() << std::endl;
    //重置值
    reset(&a,&b,&c);


    //混合捕获  [a,b,&c]
    auto fun5 = [&,a](){
        //a =10 //a 是值不可以修改可以修改
        b=40;
        c=20;
        return a+b+c;
    };
    std::cout << "fun5:" << fun5() << std::endl;
    //重置值
    reset(&a,&b,&c);

    //不捕获  []
    auto fun6 = [](){
        //a =10  //不能修改
        // b=40; //不能修改
        // c=20;   //不能修改
        return 1;
    };
    std::cout << "fun6:" << fun6() << std::endl;
    //重置值
    reset(&a,&b,&c);


    //捕获 this（访问类成员变量）
    class MyClass {
        public:
            int value = 100;
            void print() {
                auto lambda = [this]() {
                     // 可以访问类成员 value
                    std::cout <<"MyClass.value :"<< this->value << std::endl;
                };
                lambda();
            }
    };

    MyClass obj;
    obj.print(); // 输出 100
   return 0;
}

数字

随机数

#include <iostream>
#include <ctime>
#include <cstdlib>
using namespace std;

int main() {
    //同样的种子生成随机数的顺序相同
    srand(1);
    // srand(time(NULL));  // 用时间初始化种子

    for (int i = 0; i < 10; i++) {
       //生成100~1000的随机数
       //  rand() % 901 可能的结果是0~900 + 100 则 100~1000
        int j = rand() % 901 + 100;
        cout << "3位随机数：" << j << endl;
    }
    return 0;
}

数组

#include <iostream>
using namespace std;

#include <iomanip>
using std::setw;

int main (){
   int n[ 10 ]; // n 是一个包含 10 个整数的数组

   // 初始化数组元素
   for ( int i = 0; i < 10; i++ ){
      n[ i ] = i + 100; // 设置元素 i 为 i + 100
   }
   cout << "Element" << setw( 13 ) << "Value" << endl;

   // 输出数组中每个元素的值
   for ( int j = 0; j < 10; j++ ){
      cout << setw( 7 )<< j << setw( 13 ) << n[ j ] << endl;
   }

   return 0;
}

字符串

#include <iostream>

using namespace std;

int main (){
   char str1 [] = "Greeting message: ";
   char str2[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
   char* str3 = " world";
   cout << str1 << str2 << str3 << endl;


   std::string a = "C++ new world";
   cout << a << " size:"<< a.size()  << endl;
   return 0;
}

指针

貌似和C的指针差不多

#include <iostream>

using namespace std;

int main (){
   int  var = 20;   // 实际变量的声明
   int  *ip;        // 指针变量的声明

   ip = &var;       // 在指针变量中存储 var 的地址

   cout << "Value of var variable: ";
   cout << var << endl;

   // 输出在指针变量中存储的地址
   cout << "Address stored in ip variable: ";
   //输出指针地址
   cout << ip << endl;

   // 访问指针中地址的值
   cout << "Value of *ip variable: ";
   //指针解引用
   cout << *ip << endl;

   return 0;
}

引用

#include <iostream>

using namespace std;

int main (){
   // 声明简单的变量
   int    i;
   double d;
   // 声明引用变量

   int&  r = i; // r 是 i 的别名（同一内存，无拷贝）。
   int *pi  = &i; //pi 存储 i 的地址（需解引用操作）。

   i = 5;
   cout << "i 内存地址:" << &i << endl;
   cout << "r 内存地址:" << &r << endl;
   cout << "指针pi:" << pi << " 解引用："<< *pi<< endl;
   cout << "i : " << i << endl;
   cout << "r : " << r  << endl;

   double& s = d;
   double *pd  = &d;

   d = 11.7;
   cout << "d 内存地址:" << &d << endl;
   cout << "s 内存地址:" << &s  << endl;
   cout << "指针pd:" << pd << " 解引用："<< *pd<< endl;
   cout << "d : " << d << endl;
   cout << "s: " << s  << endl;

   return 0;
}

时间

#include <iostream>
#include <time.h>

using namespace std;

int main (){
    //返回系统的当前日历时间，自 1970 年 1 月 1 日以来经过的秒数。如果系统没有时间，则返回 .1。
    time_t now = time(NULL);
    cout << "秒:"<< now << endl;

     //返回一个表示当地时间的字符串指针
    char* dt = ctime(&now);

    cout << "本地日期和时间：" << dt << endl;

    //该函数返回一个指向 time 的指针，time 为 tm 结构，用协调世界时（UTC）也被称为格林尼治标准时间（GMT）表示。
    tm *gmtm = gmtime(&now);

    //该函数返回一个指向字符串的指针，字符串包含了 time 所指向结构中存储的信息，返回形式为：day month date hours:minutes:seconds year\n\0。
    dt = asctime(gmtm);
    cout << "UTC 日期和时间："<< dt << endl;

    //该函数返回一个指向表示本地时间的 tm 结构的指针。
    tm *ltm = localtime(&now);

    // 输出 tm 结构的各个组成部分
    //点（.）是用于结构体变量访问成员，箭头（->）是用于结构体指针访问成员。
    cout << "年: "<< 1900 + ltm->tm_year << endl;
    cout << "月: "<< 1 + ltm->tm_mon<< endl;
    cout << "日: "<<  ltm->tm_mday << endl;
    cout << "时间: "<< ltm->tm_hour << ":";
    cout << ltm->tm_min << ":";
    cout << ltm->tm_sec << endl;
    return 0;
}

输入输出

#include <iostream>

int main (){
    std::string name;
    std::cout << "请输入姓名:";
    std::cin >> name;
    std::cout << "你的名字是:" << name << std::endl;

    std::string sex;
    std::cout << "请输入性别:";
    std::cin.ignore();
    std::getline(std::cin,sex);
    std::clog << "你的性别是:" << sex << std::endl;

    int  age;
    std::cout << "请输入年龄:";
    std::cin >> age;
    std::cerr << "你的年龄是:" << age << std::endl;

    return 0;
}

结构体

语法

struct type_name {
  member_type1 member_name1;
  member_type2 member_name2;
  member_type3 member_name3;
  .
  .
} object_names;

type_name 是结构体类型的名称，

member_type1 member_name1 是标准的变量定义，比如 int i; 或者 float f; 或者其他有效的变量定义。

在结构定义的末尾，最后一个分号之前，您可以指定一个或多个结构变量：

#include <iostream>
#include <cstring>

using namespace std;

//同名不同参，方法重载
void printBook( struct Books *book );
void printBook( struct Books book );

typedef  struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} BOOK,B;//可指定一个或者多个名称

int main( )
{
   Books Book1;
   BOOK Book2;        // 定义结构体类型 Books 的变量 Book1
   B Book3;        // 定义结构体类型 Books 的变量 Book2

    // Book1 详述
   strcpy( Book1.title, "C++ 教程");
   strcpy( Book1.author, "Nowcoder"); 
   strcpy( Book1.subject, "编程语言");
   Book1.book_id = 12345;
   // 通过传 Book1 的地址来输出 Book1 信息
   printBook( &Book1 );

   // Book2 详述
   strcpy( Book2.title, "CSS 教程");
   strcpy( Book2.author, "Nowcoder");
   strcpy( Book2.subject, "前端技术");
   Book2.book_id = 12346;
   // 通过传 Book2 的地址来输出 Book2 信息
   printBook( Book2 );


   // Booke 详述
   strcpy( Book3.title, "C++从入门到放弃");
   strcpy( Book3.author, "小菜鸟");
   strcpy( Book3.subject, "编程语言");
   Book3.book_id = 9999;
   // 通过传 Book3 的地址来输出 Book3 信息
   printBook( Book3 );
   return 0;
}

// -> 结构体指针访问
void printBook( struct Books *book )
{
   cout << "指针->书标题  : " << book->title <<endl;
   cout << "指针->书作者 : " << book->author <<endl;
   cout << "指针->书类目 : " << book->subject <<endl;
   cout << "指针->书 ID : " << book->book_id <<endl;
}

// . 结构体变量访问
void printBook( struct Books book )
{
   cout << "书标题  : " << book.title <<endl;
   cout << "书作者 : " << book.author <<endl;
   cout << "书类目 : " << book.subject <<endl;
   cout << "书 ID : " << book.book_id <<endl;
}

面向对象