LogNote - Log Viewer: 2023

c++ const functions and mutable

A const function prevents its value from being changed, but the value can be changed by using the mutable keyword.

Why is mutable necessary for a function that intentionally prevents its value from changing?

A const for a variable passed as a function parameter prevents the value itself from being changed, enabling safe use.

To ensure that a function does not change the value of a member variable, the const keyword is applied to the function declaration.

The const function raises several exceptions.

1. Cannot call functions other than the same const function.

	#include <iostream>
	class Aa {
	public:
	virtual void printTest() const {
	std::cout << "Test" << std::endl;
	printTest2();
	printTest3();
	}
	void printTest2() const {
	std::cout << "Test 2" << std::endl;
	}
	void printTest3() {
	std::cout << "Test 3" << std::endl;
	}
	};

	int main() {
	Aa a = Aa();
	a.printTest();

	return 0;
	}

	// $ g++ Test00.cpp
	// Test00.cpp: In member function ‘virtual void Aa::printTest() const’:
	// Test00.cpp:7:24: error: passing ‘const Aa’ as ‘this’ argument discards qualifiers [-fpermissive]
	// 7 \| printTest3();
	// \| ^
	// Test00.cpp:12:14: note: in call to ‘void Aa::printTest3()’
	// 12 \| void printTest3() {
	// \|

view raw ConstMutableTest00.cpp hosted with ❤ by GitHub

2. Member variable values cannot be changed. (Global variables can be changed)

In most cases, this is the desired situation.

	#include <iostream>

	int sS = 0;
	class Aa {
	public:
	int mA = 0;
	virtual void printTest() const {
	mA = 1;
	sS = 1;
	std::cout << "Test " << mA << std::endl;
	printTest2();
	}
	void printTest2() const {
	std::cout << "Test 2" << std::endl;
	}
	};

	int main() {
	Aa a = Aa();
	a.printTest();

	return 0;
	}

	// $ g++ Test00.cpp
	// Test00.cpp: In member function ‘virtual void Aa::printTest() const’:
	// Test00.cpp:8:12: error: assignment of member ‘Aa::mA’ in read-only object
	// 8 \| mA = 1;
	// \| ~~~^~~

view raw ConstMutableTest01.cpp hosted with ❤ by GitHub

If const is set on a class member function under development, it can be modified accordingly when there is an issue.

If setting it as const is difficult, you can solve it by deleting it.

The problem arises when you use an unmodifiable library and you need to override a const function.

	#include <iostream>
	class Aa {
	public:
	virtual void printTest() const = 0;
	void printTest2() const {
	printTest();
	std::cout << "Test 2" << std::endl;
	}
	};

	class Bb : public Aa {
	public:
	virtual void printTest() const {
	std::cout << "Test" << std::endl;
	}
	};

	int main() {
	Bb b = Bb();
	b.printTest2();

	return 0;
	}

view raw ConstMutableTest02.cpp hosted with ❤ by GitHub

If class Aa is a library class, Ba must define a const function.

If you need to change member variable values in Ba class, you cannot delete const or call a function without const.

At this time, if mutable is designated for the member number, the value of the member variable can be changed.

	#include <iostream>
	class Aa {
	public:
	virtual void printTest() const = 0;
	void printTest2() const {
	printTest();
	std::cout << "Test 2" << std::endl;
	}
	};

	class Bb : public Aa {

	mutable int mB = 0; // <<<<<<<<<<<<<<<<<<<<<<<<<<<<

	public:
	virtual void printTest() const {
	mB = 1;
	std::cout << "Test" << std::endl;
	}
	};

	int main() {
	Bb b = Bb();
	b.printTest2();

	return 0;
	}

view raw ConstMutableTest03.cpp hosted with ❤ by GitHub

In general, const is used when you do not want to change the value of a member variable, so using mutable is awkward.

What if the printTest function runs in a multi-threaded environment and needs to be synchronized with a mutex?

void std::mutex::lock(); The function is not a const function, so you cannot use it in printTest.

	#include <iostream>
	#include <mutex>
	class Aa {
	public:
	virtual void printTest() const = 0;
	void printTest2() const {
	printTest();
	std::cout << "Test 2" << std::endl;
	}
	};

	class Bb : public Aa {
	private:
	std::mutex mMutex;
	public:
	virtual void printTest() const {
	mMutex.lock();
	std::cout << "Test" << std::endl;
	mMutex.unlock();
	}
	};

	int main() {
	Bb b;
	b.printTest2();

	return 0;
	}

	// $ g++ Test.cpp
	// Test.cpp: In member function ‘virtual void Bb::printTest() const’:
	// Test.cpp:17:25: error: passing ‘const std::mutex’ as ‘this’ argument discards qualifiers [-fpermissive]
	// 17 \| mMutex.lock();
	// \| ^
	// In file included from /usr/include/c++/9/mutex:43,
	// from Test.cpp:2:
	// /usr/include/c++/9/bits/std_mutex.h:98:5: note: in call to ‘void std::mutex::lock()’
	// 98 \| lock()
	// \| ^~~~
	// Test.cpp:19:27: error: passing ‘const std::mutex’ as ‘this’ argument discards qualifiers [-fpermissive]
	// 19 \| mMutex.unlock();
	// \| ^
	// In file included from /usr/include/c++/9/mutex:43,
	// from Test.cpp:2:
	// /usr/include/c++/9/bits/std_mutex.h:115:5: note: in call to ‘void std::mutex::unlock()’
	// 115 \| unlock()
	// \| ^~~~~~

view raw ConstMutableTest04.cpp hosted with ❤ by GitHub

"mutable std::mutex mMutex;" Similarly, if mutable is used, locking is possible even in const functions.

mutable is seen as a necessary feature for situations like this where it is logically necessary but can't use by const.

gist - to organize example code

The most necessary and used thing while writing a programming blog is to organize the code.

I applied a plugin that handles code highlighting for each blog, but it is not as easy to manage as I thought.

Explains how to organize example code using gist.

1. Go to gist ( https://gist.github.com/ )

2. After logging in, a screen for creating a new code appears.

3. Write the content.

- Gist description: A brief description of the code. You don't have to enter it, but think about it when you look at it again later.

- Filename including extension: Code highlighting according to the extension.

- Enter code

- Create secret gist: It is not searchable, but anyone can see it. (If you declare it as public, you can search it)

4. Import to your blog

- Copy the script code from Embed.

- Go to the blog html view.

- After pasting the copied code, check it in the blog preview.

- A code added through Add file moves together through Embed code.

=> If you want to do it individually, you need to create a new one through "+" at the top right, not Add file.

It is managed by revision, so it is possible to check previous revisions.

I won't use it often, but I think I'll see the previous contents at least once.

View the code applied to the blog

	#include <stdio.h>

	int main() {
	printf("hello world");
	return 0;
	}

view raw helloworld.c hosted with ❤ by GitHub

	#include <stdio.h>

	int main() {
	printf("hello world2");
	return 0;
	}

view raw helloworld2.c hosted with ❤ by GitHub

Kotlin syntax different from Java

While using kotlin, it summarizes differences from java and sample codes.

0. The main function does not have to be inside a class.

If the main function is defined without a class, a class is created with the file name and the main function is put into it.

	fun main(args: Array<String>) {
	println("Hello World!")
	}
	//// java code
	//public final class MainKt {
	// public static final void main(@NotNull String[] args) {
	// System.out.println("Hello World!");
	// }
	//}

view raw AboutKotlin00.kt hosted with ❤ by GitHub

1. All primitive types are classes.

Basic types are not very different from Java, but they are all in the form of classes.

	// Base type is class
	fun main(args: Array<String>) {
	val a: Byte = 0 // 8
	val b: Short = 0 // 16
	val c: Int = 0 // 32
	val d: Long = 0 // 64
	val e: UByte = 0u
	val f: UShort = 0u
	val g: UInt = 0u
	val h: ULong = 0u
	val i: Float = 0F
	val j: Double = 0.0
	val k: Float = 0F
	val l: Double = 0.0

	val bool: Boolean = true

	val ch: Char = 'a'
	val str: String = "abc"
	}

view raw AboutKotlin01.kt hosted with ❤ by GitHub

2. At compile time, a check is made for the scope of the base type.

An error occurs when initializing a value beyond the maximum value, such as val a: Byte = 500.

You can prevent overflow for an initial wrong type.

	// If out of the range according to the type, an error occurs.
	// The type is automatically set according to the given value.
	fun main(args: Array<String>) {
	// val a: Byte = 500 // compile error
	val c = 0
	val bool = true
	val ch = 'a'
	val str = "abc"

	c.toString() // has method
	}

view raw AboutKotlin02.kt hosted with ❤ by GitHub

3. Add fun to function definitions, val and var to variable definitions.

fun foo(a: Int): Int // fun function_name(parameter): return_type

Add val or var in front of a variable, where val means that does not change to value, and var means that changes to variable.

	// define function
	fun foo(a: Int): Int {
	return 0
	}

	// val : value, var : variable
	fun main(args: Array<String>) {
	val a = foo(0)

	// val, var
	val c = 0
	c = 1 // compile error
	var d = 0
	d = 1
	}

view raw AboutKotlin03.kt hosted with ❤ by GitHub

4. Using a for loop

Can be used in multiple styles.

	// for loop
	fun main(args: Array<String>) {
	for (x in 1..5) {
	// 1, 2, 3, 4, 5
	}

	for (x in 1 until 5) {
	// 1, 2, 3, 4
	}

	for (x in 5 downTo 1) {
	// 5, 4, 3, 2, 1
	}

	for (x in 1..5 step 2) {
	// 1, 3, 5
	}

	for (item in args) {

	}

	for (item in args.indices) {

	}
	}

view raw AboutKotlin04.kt hosted with ❤ by GitHub

5. if, when

You can use an if statement as a value, like val c = if (a == 5) "a is 5" else "a is not 5". In this case, there should always be an else.

You can think of using when instead of switch. Use else instead of default.

The values used in when are used from basic types to class objects,

Multiple values can be grouped into one item using ','.

	// if, when
	class Cat(n: String, w: Int) {
	val name = n
	var weight = w
	}
	fun main(args: Array<String>) {
	val a = 5
	val b = "abc"

	val c = if (a == 5) "a is 5" else "a is not 5"
	println(c)

	when (a) {
	1 -> println("1")
	2,3,4 -> { println("2,3,4") }
	5 -> println("5")
	else -> println("else")
	}

	when (b) {
	"abc" -> println("1")
	else -> println("else")
	}

	val cat = Cat("a", 0)
	val cat1 = Cat("a", 0)
	// val cat1 = cat
	when (cat) {
	cat1 -> println("cat 1")
	else -> println("cat else")
	}
	}

view raw AboutKotlin05.kt hosted with ❤ by GitHub

6. Defining member variables

If the class name parameter is defined as val or var, it becomes a member variable. It is mainly used in "data class" types.

Member variables can be initialized with the passed parameters, and can also be initialized using the init block.

In the case of var variables, you can use lateinit to delay initialization (initialize them before use).

lateinit cannot be used on val variables. val is immutable and must be initialized at creation time.

	// class
	class Dog(val name: String, var weight: Int) {

	}

	class Cat(n: String, w: Int) {
	val name = n
	var weight = w
	}

	class Wolf(n: String, w: Int) {
	val name: String
	var weight: Int

	init {
	name = n
	weight = w
	}
	}

	class Duck(n: String, w: Int) {
	val name = n
	// lateinit var weight: Int // lateinit - Not applicable to basic types
	var weight: Int = 0
	lateinit var dog: Dog

	fun foo() {
	weight = 0
	dog = Dog("aaa", 0)
	}
	}

view raw AboutKotlin06.kt hosted with ❤ by GitHub

7. Defining getters and setters

In Java, you need to define get~, set~ methods, but in kotlin, you can attach get(), set(value) under member variables.

Getters and setters are simply defined, and set and get are automatically called when values are assigned or used as if using variables.

	// getter setter
	class Cat() {
	val name: String
	get() { return "abc" }

	var weight: Int = 0
	get() {
	return if (field < 0)
	-1
	else
	field
	}
	set(value) {
	println("Hello")
	field = value
	}
	}

view raw AboutKotlin07.kt hosted with ❤ by GitHub

8. Using Inheritance

A class in Kotlin is a final class in Java. not inherited

Kotlin's open class is Java's class. inheritance is possible

Functions that can be overridden are prefixed with "open". When override it, add "override" in front.

Abstract classes are defined using the "abstract" keyword.

	// open class
	open class Animal() {
	open val name: String = ""

	open fun print() {
	println("Animal $name")
	}

	private fun print2() {
	println("Animal2 $name")
	}
	}

	class Cat(): Animal() {
	override val name: String = "cat"

	override fun print() {
	println("Cat $name")
	}

	fun print2() {
	println("Cat2 $name")
	}
	}

	fun main(args: Array<String>) {
	val cat = Cat()
	val animal: Animal = cat

	cat.print()
	cat.print2()

	animal.print()
	animal.print2()
	}

	// ===================================================

	// abstract class
	abstract class Animal() {
	abstract val name: String

	abstract fun print()

	private fun print2() {
	println("Animal2 $name")
	}
	}

	class Cat(): Animal() {
	override val name: String = "cat"

	override fun print() {
	println("Cat $name")
	}

	fun print2() {
	println("Cat2 $name")
	}
	}

	fun main(args: Array<String>) {
	val cat = Cat()
	val animal: Animal = cat

	cat.print()
	cat.print2()

	animal.print()
	// animal.print2()

	println("${animal is Cat}")
	val animal2 = cat as Animal
	}

view raw AboutKotlin08.kt hosted with ❤ by GitHub

9. Null Stability - 1

When defining a variable, add "?" to determine whether to use null.

var testName: String? = null

If you attach "!!" when using it, a null pointer exception occurs when it is a null value, as when using it in java.

If you use it with "?", it doesn't do anything if it is a null value.

dog.printName() // compile error
cat2.printName()

Both of them did a null check in the if statement, but one generated a compilation error and the other did not.

The difference is whether the value of the variable can be changed after the if statement.

If dog is a member variable and operates in multi-thread, it may change in another thread immediately after passing the if statement.

cat2 is a local variable that cannot be changed within the function. After checking for null, "." It is possible to use only

	// null safety - 1
	class Dog(n: String, w: Int) {
	val name = n
	var weight = w

	var testName: String? = null

	fun printName() {
	testName = "aa"
	}
	}

	class Cat(n: String, w: Int) {
	val name = n
	var weight = w

	var dog: Dog? = null

	fun printName() {
	dog = Dog("a", 5)
	}

	fun testPrintName() {
	if (dog != null) {
	// dog.printName() // compile error
	}

	dog!!.printName() // if null, exception
	dog?.printName()
	}
	}

	fun testPrint1() {
	var cat2: Cat? = null

	if (cat2 != null) {
	cat2.printName()
	}
	}

view raw AboutKotlin09.kt hosted with ❤ by GitHub

10. Null Stability - 2

dog?.let defines a block that operates only when dog is not null and accesses dog using "it".

The elvis operator "?:" simplifies the if statement.

	// null safety - 2
	class Dog(n: String, w: Int) {
	val name = n
	var weight = w
	}

	class Cat(n: String, w: Int) {
	var dog: Dog? = null

	fun testPrintName() {
	var num: Int? = null
	if (dog != null) {
	println("dog is not null")
	}

	dog?.let {
	println("dog is not null ${it.name}")
	}

	val aa = if (num != null) {
	num
	} else {
	-1
	}
	val bb = num ?: -1
	}
	}

view raw AboutKotlin10.kt hosted with ❤ by GitHub

11. data class

It is defined by attaching data in front of the class name. If the defined value is the same in the constructor parameter, true is returned during == operation.

Use "===" to check whether objects are the same.

The data class internally defines several methods such as copy and equals. (Recommended to convert and compare with java code)

	data class Book(val title: String, val isNew: Boolean)
	class BookNotData(val title: String, val isNew: Boolean)

	fun main(args: Array<String>) {
	val nr1 = BookNotData("Snow White", false)
	val nr2 = BookNotData("Snow White", false)
	// val nr3 = nr1.copy(title = "Cinderella") // compile error

	println("nr1 hash code : ${nr1.hashCode()}")
	println("nr2 hash code : ${nr2.hashCode()}")

	println("nr1 toString : ${nr1.toString()}")
	println("nr2 toString : ${nr2.toString()}")

	println("nr1 == nr2? ${nr1 == nr2}")
	println("nr1 === nr2? ${nr1 === nr2}")

	println("#####################################################")

	val r1 = Book("Snow White", false)
	val r2 = Book("Snow White", false)
	val r3 = r1.copy(title = "Cinderella")

	println("r1 hash code : ${r1.hashCode()}")
	println("r2 hash code : ${r2.hashCode()}")
	println("r3 hash code : ${r3.hashCode()}")

	println("r1 toString : ${r1.toString()}")
	println("r2 toString : ${r2.toString()}")
	println("r3 toString : ${r3.toString()}")

	println("r1 == r2? ${r1 == r2}")
	println("r1 === r2? ${r1 === r2}")
	println("r1 == r3? ${r1 == r3}")

	val (title, isNew) = r1
	println("title is $title and it is new $isNew")
	}

view raw AboutKotlin11.kt hosted with ❤ by GitHub

12. Using Arrays

Returns an array whose values are set through arrayOf.

The value of the array can be changed (you can see what it means by comparing it to List).

There is also a way to define the number other than value setting, and it is possible to set an initial value like "IntArray(10) { index -&gt index }".

In the case of arrays related to numbers like Int type, frequently used operation functions such as sum and average are added.

	fun mainTest1(args: Array<String>) {
	val array = arrayOf(1, 3, 2)
	val array2 = arrayOf('a', 'b', 'c')
	val array3 = arrayOf("ab", "bc", "ca")
	var array4: Array<String?> = arrayOfNulls(2)
	val array5 = IntArray(10)
	val array6 = IntArray(10) { index -> index }
	print("array5 : ")
	for (item in array5) {
	print("$item, ")
	}
	println()

	print("array6 : ")
	for (item in array6) {
	print("$item, ")
	}
	println()
	}

	fun mainTest2(args: Array<String>) {
	val array = arrayOf(1, 3, 2)
	val size = array.size
	for (item in array) {
	print("$item, ")
	}
	println()

	array.reverse()
	for (item in array) {
	print("$item, ")
	}
	println()

	val isIn = array.contains(1)
	val sum = array.sum()
	val average = array.average()

	println("$sum, $isIn, $average")

	array.sort()
	for (item in array) {
	print("$item, ")
	}
	println()
	}

view raw AboutKotlin12.kt hosted with ❤ by GitHub

13. List, MutableList

The main data storage types include a List with order, a Set without duplicate values, and a Map connected with a key.

These types cannot be changed in value, and if you want to change it, define it as a type with Mutable attached. (MutableList...)

	fun main(args: Array<String>) {
	val muList = mutableListOf("tea", "egg")
	val list = listOf("tea", "egg")
	// list[0] = "a"
	// list.add("test")
	val list2 = muList.toList()
	muList.add("apple")
	val list3 = muList.toList()

	print("list2 : ")
	for (item in list2) {
	print("$item, ")
	}
	println()

	print("list3 : ")
	for (item in list3) {
	print("$item, ")
	}
	println()

	muList[0] = "milk"
	print("muList : ")
	for (item in muList) {
	print("$item, ")
	}
	println()
	println("muList size : ${muList.size}")
	muList.remove("apple")
	println("muList size : ${muList.size}")
	muList.removeAt(0)
	println("muList size : ${muList.size}")
	for (item in muList) {
	print("mu $item, ")
	}
	println()
	}

view raw AboutKotlin13.kt hosted with ❤ by GitHub

14. Lambda expression

These days, when you look at development languages, you often see support for lambda expressions (c++, java, etc.).

It is a useful development method if you know and use it.

This expression is used when you want to access the created object's variable from another object and create the desired result.????

As I said, it is not easy to explain, but I recommend that you understand it by looking at several sample codes.

In the example code, { num -> list.contains(num) } is created as an internal object and its reference is passed to LambdaTest.

It's important to understand where lambda expressions act as inner objects.

	class LambdaTest(val test: (Int) -> Boolean) {
	var checkNum = 1
	fun isOk(): Boolean {
	return test(checkNum)
	}
	}

	class LambdaUser(arg: List<Int>) {
	var list = arg

	fun test() {
	val lambdaTest1 = LambdaTest() { num -> list.contains(num) }
	println("test : ${lambdaTest1.isOk()}")
	val lambdaTest2 = LambdaTest() { num -> list.contains(num) == false }
	println("test : ${lambdaTest2.isOk()}")
	}
	}

	fun main(args: Array<String>) {
	val lambdaUser1 = LambdaUser(listOf(1, 2, 3, 4, 5))
	lambdaUser1.test()
	println("#######")
	val lambdaUser2 = LambdaUser(listOf(2, 3, 4, 5))
	lambdaUser2.test()
	}

view raw AboutKotlin14.kt hosted with ❤ by GitHub

15. Coroutines are not multi-threaded.

When I first saw it, I understood it as a multi-threaded concept because it said light concurrent work.

The operation is completely different because it is a concurrent operation that is performed without context switching.

When calling delay, which is used for coroutines, the control passes to scope management.

I think each coroutine will be called according to the delay time, but unlike multi-threading, the guarantee that it will be called is weak.

If the coroutine execution is short and a delay is called to move to scope management, you may get the desired result.

If coroutine execution is long, coroutines within the same scope are not guaranteed to be executed in time.

If you put sleep, other coroutines do not work until sleep ends.

It is used when asynchronous execution with short execution time is required.

	import kotlinx.coroutines.*
	import java.lang.Thread.sleep
	import java.time.Instant
	import java.time.ZoneOffset
	import java.time.format.DateTimeFormatter

	fun main() = runBlocking {
	printTime()
	doWorld()
	printTime()
	println("Done")
	}

	fun printTime() {
	println(
	DateTimeFormatter
	.ofPattern("yyyy-MM-dd HH:mm:ss.SSSSSS")
	.withZone(ZoneOffset.UTC)
	.format(Instant.now())
	)
	}

	suspend fun doWorld() = coroutineScope {
	launch {
	delay(2000L)
	printTime()
	println("World 2 ")
	}
	launch {
	delay(1000L)
	printTime()
	println("World 1")
	// sleep(3000)
	}
	launch {
	printTime()
	println("Hello")
	}
	}

view raw AboutKotlin15.kt hosted with ❤ by GitHub

Change to a lower version of the ubuntu kernel

When changing the kernel version in ubuntu, proceed in the following order.

Install the kernel to change

sudo apt install linux-image-5.15.0-70-generic

change grub order

Change GRUB_DEFAULT="1>4" in /etc/default/grub file
The meaning of "1>4" is to select 4 (5th item) after moving 1 (advanced, second) in the grub menu.
The value can change depending on the kernel installed situation. (/boot/grub/grub.cfg)

Apply grub changes

sudo update-grub

If the driver does not operate normally after booting, install the following two packages additionally

If already installed, reinstall with reinstall instead of install

sudo apt install linux-headers-5.15.0-70-generic
sudo apt install linux-modules-extra-5.15.0-70-generic

Checking when lock and unlock are called in std::lock_guard and std::unique_lock

std::lock_guard calls lock at creation time and unlock at destruction time (end of block).

std::unique_lock calls lock at creation time and unlock at destruction time (end of block).

In addition, lock and unlock can be called (maintaining the state value for lock).


#include <iostream>
#include <string>
#include <mutex>
 
class TestMutex {
    public:
        void lock() {
            std::cout << "call lock" << std::endl;
        }
        void unlock() {
            std::cout << "call unlock" << std::endl;
        }
};
 
TestMutex mutex1;
 
int main() {
    std::cout << "###### lock_guard start" << std::endl;
    {
        std::lock_guard lockGuard(mutex1);
        std::cout << "lock_guard created" << std::endl;
    }
    std::cout << "###### lock_guard end" << std::endl << std::endl;
 
    std::cout << "###### unique_lock start" << std::endl;
    {
        std::unique_lock uniqueLock(mutex1);
        std::cout << "unique_lock created" << std::endl;
    }
    std::cout << "###### unique_lock end" << std::endl << std::endl;
 
    std::cout << "###### unique_lock start 2" << std::endl;
    {
        std::unique_lock uniqueLock(mutex1);
        std::cout << "unique_lock created" << std::endl;
        std::cout << "manual call unlock ++" << std::endl;
        uniqueLock.unlock();
        std::cout << "manual call unlock --" << std::endl;
    }
    std::cout << "###### unique_lock end 2" << std::endl << std::endl;
 
    std::cout << "###### unique_lock start 3" << std::endl;
    {
        std::unique_lock uniqueLock(mutex1);
        std::cout << "unique_lock created" << std::endl;
        std::cout << "manual call unlock ++" << std::endl;
        uniqueLock.unlock();
        std::cout << "manual call unlock --" << std::endl;
        std::cout << "manual call lock ++" << std::endl;
        uniqueLock.lock();
        std::cout << "manual call lock --" << std::endl;
    }
    std::cout << "###### unique_lock end 3" << std::endl << std::endl;
 
 
    return 0;
}

Execution result


$ ./a.out
###### lock_guard start
call lock
lock_guard created
call unlock
###### lock_guard end

###### unique_lock start
call lock
unique_lock created
call unlock
###### unique_lock end

###### unique_lock start 2
call lock
unique_lock created
manual call unlock ++
call unlock
manual call unlock --
###### unique_lock end 2

###### unique_lock start 3
call lock
unique_lock created
manual call unlock ++
call unlock
manual call unlock --
manual call lock ++
call lock
manual call lock --
call unlock
###### unique_lock end 3

grep previous line next line


grep -B 1 TEXT file      // previous line
grep -A 1 TEXT file      // next line
grep -a 1 TEXT file      // previous and next lines

When programming is hard

There are no coding rules.
It's a code that many people see, but there is no response 
even if you shout coding rules, and the code is getting harder and harder to see.
The result is that I am the only one who is sensitive.

Copy the repeated logic.
The code will have the same logic A, A', A'', A'''. 
You can fix the problem quickly, but it's hard later.
Later, there was a problem with A, so I fixed it, and after a while, I am fixing A'... After a while...
Let's subtract with a function what we think is repeated.

Programming languages also change.
C++ 20 years ago is different from C++ now.
Most, but not all, newer versions will find an easier way.
When you ctrl-c ctrl-v on old code, see if it can be improved.

Refactoring
"It's working fine. Leave it as it is."
If I change it, it's my responsibility... I can't touch it

install ubuntu 16.04 python 3.6

Run below command


sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt-get update
sudo apt-get install python3.6
python3 --version
sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.5 1
sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.6 2
sudo update-alternatives --config python3

Common mistakes when using buffer sizing functions such as strncpy, snprintf, and strncmp

strncpy, snprintf : specify buffer size as source string size => must specify destination buffer size

There are many cases where the size of src and dst in the same function are the same, so there are few cases where the problem occurs

However, a problem occurs when receiving src as a function argument.


char* src = "012345678";
char dst[5] = { 0, };

strncpy(dst, src, strlen(src)); // buffer overflow
snprintf(dst, strlen(src), "%s", src); // buffer overflow

strncmp: String comparison is used for purposes that do not exceed the buffer size, such as the above function, resulting in unintended results.

When specifying the number, it is used only when only the first n characters of the string need to be compared, and strcmp is used to compare the entire string.


char* str1 = "";
char* str2 = "abcd";

strncmp(str1, str2, strlen(str1)); // return 0 : equal, no character comparison as n value is 0
strncmp(str1, str2, strlen(str2)); // return non-zero value: different

char* str3 = "ab";
char* str4 = "abcd";

strncmp(str3, str4, strlen(str3)); // return 0 : equal, compare the first 2 characters
strncmp(str3, str4, strlen(str4)); // return non-zero value: different

Using strcpy, strncpy, sprintf, and snprintf safely

strcpy: The length of src must be less than the length of dst.


char *src = "AAA";
char dst[10] = { 0, };
if (strlen(src) < sizeof(dst) {
	strcpy(dst, src);
}

strncpy: If the length of src is greater than or equal to dst, the '\0' at the end of dst disappears, so dst length - 1 should be set as n.


char *src = "AAA";
char dst[10] = { 0, };
strncpy(dst, src, sizeof(dst) - 1);

sprintf : The format string must not exceed dst.

snprintf : Set the length value keeping in mind that '\0' is entered at the end of the length n.


char *src = "aaaaa"
int src2 = 10000

char dst[10] = { 0, };

snprintf(dst, sizeof(dst), "%s%d", src, src2); // "aaaaa1000" The last character is truncated.

Handling text change events in JTextField and JLabel

JLabel : PropertyChangeListener

JTextField : DocumentListener

 import javax.swing.*;  
 import javax.swing.event.DocumentEvent;  
 import javax.swing.event.DocumentListener;  
 import java.beans.PropertyChangeEvent;  
 import java.beans.PropertyChangeListener;  
   
 public class TestClass {  
   JLabel mLabel = new JLabel("TEST");  
   JTextField mTextField = new JTextField("TEST");  
   
   TestClass() {  
     mLabel.addPropertyChangeListener(new MyChangeListener());  
     mTextField.getDocument().addDocumentListener(new MyDocumentListener());  
   }  
   
   private class MyChangeListener implements PropertyChangeListener {  
     @Override  
     public void propertyChange(PropertyChangeEvent evt) {  
       if ("text".equals(evt.getPropertyName())) {  
   
       }  
     }  
   }  
   
   private class MyDocumentListener implements DocumentListener {  
     @Override  
     public void insertUpdate(DocumentEvent e) {  
   
     }  
   
     @Override  
     public void removeUpdate(DocumentEvent e) {  
   
     }  
   
     @Override  
     public void changedUpdate(DocumentEvent e) {  
   
     }  
   }  
 }

Get result after run "adb logcat" in python

import subprocess
 
process = subprocess.Popen(['adb', 'logcat'], stdout=subprocess.PIPE)
while True:
    line = process.stdout.readline()
    line = line.decode('utf-8', errors='ignore')
    line = line.strip()
    print(line)