闲碎记事本
YAN
2025-03-27
目录

C++

# 基础语法 (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;
}

# 面向对象

# 类

#include <iostream>

using namespace std;

class Box
{
   public:
      double length;   // 长度
      double breadth;  // 宽度
      double height;   // 高度
};

int main( )
{
   Box Box1;        // 声明 Box1，类型为 Box
   Box Box2;        // 声明 Box2，类型为 Box
   double volume = 0.0;     // 用于存储体积

   // box 1 详述
   Box1.height = 5.0;
   Box1.length = 6.0;
   Box1.breadth = 7.0;

   // box 2 详述
   Box2.height = 10.0;
   Box2.length = 12.0;
   Box2.breadth = 13.0;

   // box 1 的体积
   volume = Box1.height * Box1.length * Box1.breadth;
   cout << "Box1 的体积：" << volume <<endl;

   // box 2 的体积
   volume = Box2.height * Box2.length * Box2.breadth;
   cout << "Box2 的体积：" << volume <<endl;
   return 0;
}

# 继承

#include <iostream>

using namespace std;

// 基类
class Shape
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};

// 派生类
class Rectangle: public Shape
{

   public:
       Rectangle(const string& n1):name(n1){
          cout << "创建一个矩形:" << name << endl;
       }
      string name;
      int getArea()
      {
         return (width * height);
      }
};

int main(void)
{

   Rectangle Rect("长方形");

   Rect.setWidth(5);
   Rect.setHeight(7);

   // 输出对象的面积
   cout << Rect.name<<"的总面积是: " << Rect.getArea() << endl;

   return 0;
}
上次更新: 2025/06/25, 10:37:22
C语言

←

最近更新
01
Caddy操作指南
04-25
02
虚拟机磁盘扩展
04-22
03
Swap空间
04-22
更多文章>
Theme by Vdoing | Copyright © 2022-2025 YAN | MIT License